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

yta_video_opengl/utils.py

@@ -1,13 +1,6 @@
-from yta_video_opengl.t import fps_to_time_base
 from yta_validation import PythonValidator
-from av.container import InputContainer
-from av.video.stream import VideoStream
-from av.audio.stream import AudioStream
-from av.video.frame import VideoFrame
-from quicktions import Fraction
 from typing import Union
 
-import av
 import numpy as np
 import moderngl
 
@@ -40,7 +33,7 @@ def frame_to_texture(
 # obtain a VideoFrame or a numpy array frame
 def texture_to_frame(
     texture: moderngl.Texture
-) -> 'VideoFrame':
+) -> np.ndarray:
     """
     Transform an opengl texture into a pyav
     VideoFrame instance.
@@ -54,9 +47,13 @@ def texture_to_frame(
 
     # This is if we need an 'av' VideoFrame (to
     # export through the demuxer, for example)
-    frame = av.VideoFrame.from_ndarray(frame, format = 'rgba')
-    # TODO: Make this customizable
-    frame = frame.reformat(format = 'yuv420p')
+    # TODO: I avoid this by now because we don't
+    # want to import the pyav library, so this
+    # below has to be done with the numpy array
+    # received...
+    # frame = av.VideoFrame.from_ndarray(frame, format = 'rgba')
+    # # TODO: Make this customizable
+    # frame = frame.reformat(format = 'yuv420p')
 
     return frame
 
@@ -103,413 +100,4 @@ def get_fullscreen_quad_vao(
         (vbo, '2f 2f', 'in_vert', 'in_texcoord'),
     ]
 
-    return context.vertex_array(program, vao_content, ibo)
-
-def iterate_streams_packets(
-    container: 'InputContainer',
-    video_stream: 'VideoStream',
-    audio_stream: 'AudioStream',
-    video_start_pts: int = 0,
-    video_end_pts: Union[int, None] = None,
-    audio_start_pts: int = 0,
-    audio_end_pts: Union[int, None] = None
-):
-    """
-    Iterate over the provided 'stream' packets
-    and yield the ones in the expected range.
-    This is nice when trying to copy a stream
-    without modifications.
-    """
-    # 'video_start_pts' and 'audio_start_pts' must
-    # be 0 or a positive tps
-
-    if (
-        video_stream is None and
-        audio_stream is None
-    ):
-        raise Exception('No streams provided.')
-    
-    # We only need to seek on video
-    if video_stream is not None:
-        container.seek(video_start_pts, stream = video_stream)
-    if audio_stream is not None:
-        container.seek(audio_start_pts, stream = audio_stream)
-    
-    stream = [
-        stream
-        for stream in (video_stream, audio_stream)
-        if stream
-    ]
-
-    """
-    Apparently, if we ignore some packets based
-    on the 'pts', we can be ignoring information
-    that is needed for the next frames to be 
-    decoded, so we need to decode them all...
-
-    If we can find some strategy to seek not for
-    the inmediate but some before and read from
-    that one to avoid reading all of the packets
-    we could save some time, but at what cost? 
-    We cannot skip any crucial frame so we need
-    to know how many we can skip, and that sounds
-    a bit difficult depending on the codec.
-    """
-    stream_finished: str = ''
-    for packet in container.demux(stream):
-        if packet.pts is None:
-            continue
-
-        # TODO: We cannot skip like this, we need to
-        # look for the nearest keyframe to be able 
-        # to decode the frames later. Take a look at
-        # the VideoFrameCache class and use it.
-
-        # start_pts = (
-        #     video_start_pts
-        #     if packet.stream.type == 'video' else
-        #     audio_start_pts
-        # )
-        # end_pts = (
-        #     video_end_pts
-        #     if packet.stream.type == 'video' else
-        #     audio_end_pts
-        # )
-
-        # if packet.pts < start_pts:
-        #     continue
-
-        # if (
-        #     end_pts is not None and
-        #     packet.pts > end_pts
-        # ):
-        #     if (
-        #         stream_finished != '' and
-        #         (
-        #             # Finish if only one stream
-        #             stream_finished != packet.stream.type or
-        #             video_stream is None or
-        #             audio_stream is None
-        #         )
-        #     ):
-        #         # We have yielded all the frames in the
-        #         # expected range, no more needed
-        #         return
-            
-        #     stream_finished = packet.stream.type
-        #     continue
-        
-        yield packet
-
-def iterate_stream_frames_demuxing(
-    container: 'InputContainer',
-    video_stream: 'VideoStream',
-    audio_stream: 'AudioStream',
-    video_start_pts : int = 0,
-    video_end_pts: Union[int, None] = None,
-    audio_start_pts: int = 0,
-    audio_end_pts: Union[int, None] = None
-):
-    """
-    Iterate over the provided 'stream' packets
-    and decode only the ones in the expected
-    range, so only those frames are decoded
-    (which is an expensive process).
-
-    This method returns a tuple of 3 elements:
-    - `frame` as a `VideoFrame` instance
-    - `t` as the frame time moment
-    - `index` as the frame index
-
-    You can easy transform the frame received
-    to a numpy array by using this:
-    - `frame.to_ndarray(format = format)`
-    """
-    # 'start_pts' must be 0 or a positive tps
-    # 'end_pts' must be None or a positive tps
-
-    # We cannot skip packets or we will lose
-    # information needed to build the video
-    for packet in iterate_streams_packets(
-        container = container,
-        video_stream = video_stream,
-        audio_stream = audio_stream,
-        video_start_pts = video_start_pts,
-        video_end_pts = video_end_pts,
-        audio_start_pts = audio_start_pts,
-        audio_end_pts = audio_end_pts
-    ):
-        # Only valid and in range packets here
-        # Here only the accepted ones
-        stream_finished: str = ''
-        for frame in packet.decode():
-            if frame.pts is None:
-                continue
-
-            time_base = (
-                video_stream.time_base
-                if PythonValidator.is_instance_of(frame, VideoFrame) else
-                audio_stream.time_base 
-            )
-
-            average_rate = (
-                video_stream.average_rate
-                if PythonValidator.is_instance_of(frame, VideoFrame) else
-                audio_stream.rate
-            )
-
-            start_pts = (
-                video_start_pts
-                if packet.stream.type == 'video' else
-                audio_start_pts
-            )
-
-            end_pts = (
-                video_end_pts
-                if packet.stream.type == 'video' else
-                audio_end_pts
-            )
-
-            if frame.pts < start_pts:
-                continue
-
-            if (
-                end_pts is not None and
-                frame.pts > end_pts
-            ):
-                if (
-                    stream_finished != '' and
-                    (
-                        # Finish if only one stream
-                        stream_finished != packet.stream.type or
-                        video_stream is None or
-                        audio_stream is None
-                    )
-                ):
-                    # We have yielded all the frames in the
-                    # expected range, no more needed
-                    return
-                
-                stream_finished = packet.stream.type
-                continue
-            
-            time_base = (
-                video_stream.time_base
-                if PythonValidator.is_instance_of(frame, VideoFrame) else
-                audio_stream.time_base 
-            )
-
-            average_rate = (
-                video_stream.average_rate
-                if PythonValidator.is_instance_of(frame, VideoFrame) else
-                audio_stream.rate
-            )
-
-            # TODO: Maybe send a @dataclass instead (?)
-            yield (
-                frame,
-                pts_to_t(frame.pts, time_base),
-                pts_to_index(frame.pts, time_base, average_rate)
-            )
-
-# TODO: These methods below have to be
-# removed because we created the new T
-# class that is working with Fractions
-# to be precise
-def t_to_pts(
-    t: Union[int, float, Fraction],
-    stream_time_base: Fraction
- ) -> int:
-    """
-    Transform a 't' time moment (in seconds) to
-    a packet timestamp (pts) understandable by
-    the pyav library.
-    """
-    return int((t + 0.000001) / stream_time_base)
-
-def pts_to_index(
-    pts: int,
-    stream_time_base: Fraction,
-    fps: Union[float, Fraction]
-) -> int:
-    """
-    Transform a 'pts' packet timestamp to a 
-    frame index.
-    """
-    return int(round(pts_to_t(pts, stream_time_base) * fps))
-
-def index_to_pts(
-    index: int,
-    stream_time_base: Fraction,
-    fps: Union[float, Fraction]
-) -> int:
-    """
-    Transform a frame index into a 'pts' packet
-    timestamp.
-    """
-    return int(index / fps / stream_time_base)
-
-def pts_to_t(
-    pts: int,
-    stream_time_base: Fraction
-) -> float:
-    """
-    Transform a 'pts' packet timestamp to a 't'
-    time moment.
-    """
-    return pts * stream_time_base
-
-
-# TODO: Move this to another utils
-def get_silent_audio_frame(
-    sample_rate: int,
-    layout = 'stereo',
-    number_of_samples: int = 1024,
-    format = 's16'
-):
-    # TODO: This could be a utils or something to
-    # directly transform format into dtype
-    dtype = {
-        's16': np.int16,
-        'flt': np.float32,
-        'fltp': np.float32
-    }.get(format, None)
-
-    if dtype is None:
-        raise Exception(f'The format "{format}" is not accepted.')
-
-    number_of_channels = len(av.AudioLayout(layout).channels)
-    # TODO: I think the option above is better
-    # number_of_channels = (
-    #     2
-    #     if layout == 'stereo' else
-    #     1
-    # )
-
-    # For packed (or planar) formats we apply:
-    # (1, samples * channels). This is the same
-    # amount of data but planar, in 1D only
-    # TODO: This wasn't in the previous version
-    # and it was working, we were sending the
-    # same 'number_of_samples' even when 'fltp'
-    # that includes the 'p'
-    # TODO: This is making the audio last 2x
-    # if 'p' in format:
-    #     number_of_samples *= number_of_channels
-
-    silent_array = np.zeros((number_of_channels, number_of_samples), dtype = dtype)
-    frame = av.AudioFrame.from_ndarray(silent_array, format = format, layout = layout)
-    frame.sample_rate = sample_rate
-    
-    return frame
-
-def get_black_background_video_frame(
-    size: tuple[int, int] = (1920, 1080),
-    format: str = 'rgb24',
-    pts: Union[int, None] = None,
-    time_base: Union[Fraction, None] = None
-):
-    """
-    Get a pyav VideoFrame that is a completely black
-    frame. If the 'pts' and/or 'time_base' parameters
-    are provided, they will be set to the frame that
-    is returned with them. If not, remember to set
-    later because they are needed to be sent to the
-    pyav muxer.
-    """
-    frame = av.VideoFrame.from_ndarray(
-        # TODO: What if we want alpha (?)
-        # Size must be inverted
-        array = np.zeros((size[1], size[0], 3), dtype = np.uint8),
-        format = format
-    )
-
-    frame.pts = (
-        pts
-        if pts is not None else
-        frame.pts
-    )
-
-    frame.time_base = (
-        time_base
-        if time_base is not None else
-        frame.time_base
-    )
-
-    return frame
-
-def get_audio_frame_pts_range(
-    frame: av.AudioFrame,
-    do_in_seconds: bool = False
-):
-    """
-    Get the [start_pts, end_pts) range of the
-    pyav AudioFrame, or in seconds if the
-    'do_in_seconds' parameter is True.
-    """
-    if frame.pts is None:
-        raise Exception('No "pts" found.')
-
-    # First and last sample. Remember that
-    # the last one is not included
-    start_pts = frame.pts
-    end_pts = frame.pts + frame.samples
-
-    # Time base for the seconds conversion
-    time_base = (
-        frame.time_base
-        if frame.time_base else
-        Fraction(1, frame.sample_rate)
-    )
-
-    start_time = (
-        float(start_pts * time_base)
-        if do_in_seconds else
-        start_time
-    )
-    end_time = (
-        float(end_pts * time_base)
-        if do_in_seconds else
-        end_time
-    )
-
-    return (
-        start_time,
-        end_time
-    )
-
-def audio_frames_and_remainder_per_video_frame(
-    # TODO: Maybe force 'fps' as int (?)
-    video_fps: Union[float, Fraction],
-    sample_rate: int, # audio_fps
-    number_of_samples_per_audio_frame: int
-) -> tuple[int, int]:
-    """
-    Get how many full silent audio frames we
-    need and the remainder for the last one
-    (that could be not complete), according
-    to the parameters provided.
-
-    This method returns a tuple containing
-    the number of full silent audio frames
-    we need and the number of samples we need
-    in the last non-full audio frame.
-    """
-    # Video frame duration (in seconds)
-    time_base = fps_to_time_base(video_fps)
-    sample_rate = Fraction(int(sample_rate), 1)
-
-    # Example:
-    # 44_100 / 60 = 735  ->  This means that we
-    # will have 735 samples of sound per each
-    # video frame
-    # The amount of samples per frame is actually
-    # the amount of samples we need, because we
-    # are generating it...
-    samples_per_frame = sample_rate * time_base
-    # The 'nb_samples' is the amount of samples
-    # we are including on each audio frame
-    full_audio_frames_needed = samples_per_frame // number_of_samples_per_audio_frame
-    remainder = samples_per_frame % number_of_samples_per_audio_frame
-    
-    return int(full_audio_frames_needed), int(remainder)
+    return context.vertex_array(program, vao_content, ibo)

{yta_video_opengl-0.0.22.dist-info → yta_video_opengl-0.0.24.dist-info}/METADATA

@@ -1,20 +1,16 @@
 Metadata-Version: 2.3
 Name: yta-video-opengl
-Version: 0.0.22
+Version: 0.0.24
 Summary: Youtube Autonomous Video OpenGL Module
 Author: danialcala94
 Author-email: danielalcalavalera@gmail.com
 Requires-Python: ==3.9
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
-Requires-Dist: av (>=0.0.1,<19.0.0)
 Requires-Dist: moderngl (>=0.0.1,<9.0.0)
 Requires-Dist: numpy (>=0.0.1,<9.0.0)
-Requires-Dist: pillow (>=0.0.1,<99.0.0)
-Requires-Dist: quicktions (>=0.0.1,<9.0.0)
-Requires-Dist: yta_timer (>0.0.1,<1.0.0)
+Requires-Dist: yta_programming (>=0.0.1,<1.0.0)
 Requires-Dist: yta_validation (>=0.0.1,<1.0.0)
-Requires-Dist: yta_video_frame_time (>=0.0.1,<1.0.0)
 Description-Content-Type: text/markdown
 
 # Youtube Autonomous Video OpenGL Module

yta_video_opengl-0.0.24.dist-info/RECORD

@@ -0,0 +1,13 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/editor.py,sha256=ILzeGAe6uO5IptwrplbvnFu8e0j8v9AOaAmuvFH4YjI,9218
+yta_video_opengl/nodes/__init__.py,sha256=Rbh6HxWpKrdF_qlcGVKYBGW6i10NodoExa5qGEMcmIM,3738
+yta_video_opengl/nodes/audio/__init__.py,sha256=upKsYZrrNW2DxP77RyMCw2I16Lj9JsHbXGALw5grxbQ,6143
+yta_video_opengl/nodes/video/__init__.py,sha256=Nf1CnUaz6m7mOvVsuoTKMsq5QIVqEqZaiGseNOre8_k,859
+yta_video_opengl/nodes/video/opengl/__init__.py,sha256=bVPdS_wpz4HNurmLRDEHUmNZU7Qz8LptKfJ9yN_2PJM,8587
+yta_video_opengl/nodes/video/opengl/experimental.py,sha256=XuriXcOuJU5P0FruKffudCpMuO-ht8weJud88Qn8GKk,22158
+yta_video_opengl/tests.py,sha256=uvTU1_cvz5r7fETd4X8hvsYw4jViMDA0x-LsDNplFPM,24265
+yta_video_opengl/utils.py,sha256=w6jYnZcBYPNAsTolkAlA6dxph0u_8-mcUzKvADlIlW8,3098
+yta_video_opengl-0.0.24.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.24.dist-info/METADATA,sha256=WKcDQFnZS0TvesGJM9N-bbPjOx0DdTNZb6yU-4nzUqY,589
+yta_video_opengl-0.0.24.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.24.dist-info/RECORD,,

yta_video_opengl/audio.py

@@ -1,219 +0,0 @@
-"""
-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
-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 Video class
-class Audio:
-    """
-    Class to wrap the functionality related to
-    handling and modifying a video.
-    """
-
-    @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 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
-        audio frames.
-        """
-        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 audio.
-        """
-        # TODO: Detect the 'pixel_format' from the
-        # extension (?)
-        self.reader: VideoReader = VideoReader(self.filename)
-        """
-        The pyav audio reader.
-        """
-        self.start: Fraction = Fraction(start)
-        """
-        The time moment 't' in which the audio
-        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 audio
-        should end.
-        """
-
-    def _get_t(
-        self,
-        t: Union[int, float, Fraction]
-    ) -> Fraction:
-        """
-        Get the real 't' time moment based on the
-        audio 'start' and 'end'. If they were 
-        asking for the t=0.5s but our audio was
-        subclipped to [1.0, 2.0), the 0.5s must be
-        actually the 1.5s of the audio because of
-        the subclipped time range.
-        """
-        t += self.start
-        
-        print(f'Audio real t is {str(float(t))}')
-        if t >= self.end:
-            raise Exception(f'The "t" ({str(t)}) provided is out of range. This audio lasts from [{str(self.start)}, {str(self.end)}).')
-        
-        return 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 a 
-        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 audio 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_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()