yta-video-opengl 0.0.8__py3-none-any.whl → 0.0.10__py3-none-any.whl

yta_video_opengl/classes.py

@@ -132,6 +132,7 @@ class _Uniforms:
         for key, value in self.uniforms.items():
             print(f'"{key}": {str(value)}')
 
+# TODO: Moved to 'nodes.opengl.py'
 class BaseNode:
     """
     The basic class of a node to manipulate frames

yta_video_opengl/nodes/__init__.py

@@ -0,0 +1,119 @@
+from yta_validation.parameter import ParameterValidator
+from typing import Union
+from abc import ABC, abstractmethod
+
+import av
+import moderngl
+
+
+class Node(ABC):
+    """
+    Base class to represent a node, which
+    is an entity that processes frames
+    individually.
+
+    This class must be inherited by any 
+    video or audio node class.
+    """
+
+    # TODO: What about the types?
+    @abstractmethod
+    def process(
+        frame: Union[av.VideoFrame, av.AudioFrame, moderngl.Texture],
+        t: float
+        # TODO: Maybe we need 'fps' and 'number_of_frames'
+        # to calculate progressions or similar...
+    ) -> Union[av.VideoFrame, av.AudioFrame, moderngl.Texture]:
+        pass
+
+class TimedNode:
+    """
+    Class to represent a Node wrapper to
+    be able to specify the time range in
+    which we want the node to be applied.
+
+    If the 't' time moment is not inside
+    this range, the frame will be returned
+    as it is, with no change.
+
+    A 't' time moment inside the range has
+    this condition:
+    - `start <= t < end`
+
+    We are not including the end because
+    the next TimedNode could start on that
+    specific value, and remember that the
+    first time moment is 0.
+
+    This is the class that has to be applied
+    when working with videos and not a Node
+    directly.
+
+    The 'start' and 'end' values by default
+    """
+
+    def __init__(
+        self,
+        node: Node,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
+        ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
+        ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
+
+        if (
+            end is not None and
+            end < start
+        ):
+            raise Exception('The "end" parameter provided must be greater or equal to the "start" parameter.')
+
+        self.node: Node = node
+        """
+        The node we are wrapping and we want to
+        apply as a modification of the frame in
+        which we are in a 't' time moment.
+        """
+        self.start: float = start
+        """
+        The 't' time moment in which the Node must
+        start being applied (including it).
+        """
+        self.end: Union[float, None] = end
+        """
+        The 't' time moment in which the Node must
+        stop being applied (excluding it).
+        """
+
+    def is_within_time(
+        self,
+        t: float
+    ) -> bool:
+        """
+        Flag to indicate if the 't' time moment provided
+        is in the range of this TimedNode instance, 
+        which means that it fits this condition:
+        - `start <= t < end`
+        """
+        return (
+            self.start <= t < self.end
+            if self.end is not None else
+            self.start <= t
+        )
+
+    def process(
+        self,
+        frame: Union[av.VideoFrame, av.AudioFrame, moderngl.Texture],
+        t: float
+        # TODO: Maybe we need 'fps' and 'number_of_frames'
+        # to calculate progressions or similar...
+    ) -> Union['VideoFrame', 'AudioFrame', 'Texture']:
+        """
+        Process the frame if the provided 't' time
+        moment is in the range of this TimedNode
+        instance.
+        """
+        return (
+            self.node.process(frame, t)
+            if self.is_within_time(t) else
+            frame
+        )

yta_video_opengl/nodes/audio/__init__.py

@@ -0,0 +1,115 @@
+"""
+When working with audio frames, we don't need
+to use the GPU because audios are 1D and the
+information can be processed perfectly with
+a library like numpy.
+
+If we need a very intense calculation for an
+audio frame (FFT, convolution, etc.) we can
+use CuPy or some DPS specific libraries, but
+90% is perfectly done with numpy.
+
+If you want to modify huge amounts of audio
+(some seconds at the same time), you can use
+CuPy, that has the same API as numpy but
+working in GPU. Doing this below most of the
+changes would work:
+- `import numpy as np` → `import cupy as np`
+"""
+from yta_video_opengl.nodes import TimedNode
+from abc import abstractmethod
+from typing import Union
+
+import numpy as np
+import av
+
+
+class AudioNode:
+    """
+    Base audio node class to implement a
+    change in an audio frame by using the
+    numpy library.
+    """
+
+    @abstractmethod
+    def process(
+        self,
+        frame: av.AudioFrame,
+        t: float
+    ):
+        """
+        Process the provided audio 'frame' that
+        is played on the given 't' time moment.
+        """
+        pass
+
+"""
+Here you have an example. The 'private'
+node class is the modifier, that we don't
+want to expose, and the 'public' class is
+the one that inherits from TimedNode and
+wraps the 'private' class to build the
+functionality.
+"""
+class VolumeAudioNode(TimedNode):
+    """
+    TimedNode to set the audio volume of a video
+    in a specific frame.
+    """
+
+    def __init__(
+        self,
+        factor_fn,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
+        super().__init__(
+            node = _SetVolumeAudioNode(factor_fn),
+            start = start,
+            end = end
+        )
+
+class _SetVolumeAudioNode(AudioNode):
+    """
+    Audio node to change the volume of an
+    audio frame.
+    """
+
+    def __init__(
+        self,
+        factor_fn
+    ):
+        """
+        factor_fn: function (t, index) -> factor volumen
+        """
+        self.factor_fn = factor_fn
+
+    def process(
+        self,
+        frame: av.AudioFrame,
+        t: float,
+    ) -> av.AudioFrame:
+        # TODO: Why index (?) Maybe 'total_frames'
+        factor = self.factor_fn(t, 0)
+
+        samples = frame.to_ndarray().astype(np.float32)
+        samples *= factor
+
+        # Determine dtype according to format
+        samples = (
+            samples.astype(np.int16)
+            # 'fltp', 's16', 's16p'
+            if 's16' in frame.format.name else
+            samples.astype(np.float32)
+        )
+
+        new_frame = av.AudioFrame.from_ndarray(
+            samples,
+            format = frame.format.name,
+            layout = frame.layout.name
+        )
+        new_frame.sample_rate = frame.sample_rate
+        new_frame.pts = frame.pts
+        new_frame.time_base = frame.time_base
+
+        return new_frame

yta_video_opengl/nodes/video/__init__.py

@@ -0,0 +1,5 @@
+"""
+Working with video frames has to be done
+with nodes that use OpenGL because this
+way, by using the GPU, is the best way.
+"""

yta_video_opengl/nodes/video/opengl.py

@@ -0,0 +1,309 @@
+from yta_video_opengl.utils import frame_to_texture, get_fullscreen_quad_vao
+from yta_video_opengl.nodes import Node
+from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
+from abc import abstractmethod
+from typing import Union
+
+import numpy as np
+import moderngl
+
+
+class _Uniforms:
+    """
+    Class to wrap the functionality related to
+    handling the opengl program uniforms.
+    """
+
+    @property
+    def uniforms(
+        self
+    ) -> dict:
+        """
+        The uniforms in the program, as a dict, in
+        the format `{key, value}`.
+        """
+        return {
+            key: self.program[key].value
+            for key in self.program
+            if PythonValidator.is_instance_of(self.program[key], moderngl.Uniform)
+        }
+
+    def __init__(
+        self,
+        program: moderngl.Program
+    ):
+        self.program: moderngl.Program = program
+        """
+        The program instance this handler class
+        belongs to.
+        """
+
+    def get(
+        self,
+        name: str
+    ) -> Union[any, None]:
+        """
+        Get the value of the uniform with the
+        given 'name'.
+        """
+        return self.uniforms.get(name, None)
+
+    # TODO: I need to refactor these method to
+    # accept a **kwargs maybe, or to auto-detect
+    # the type and add the uniform as it must be
+    # done
+    def set(
+        self,
+        name: str,
+        value
+    ) -> '_Uniforms':
+        """
+        Set the provided 'value' to the normal type
+        uniform with the given 'name'. Here you have
+        some examples of defined uniforms we can set
+        with this method:
+        - `uniform float name;`
+
+        TODO: Add more examples
+        """
+        if name in self.program:
+            self.program[name].value = value
+
+        return self
+    
+    def set_vec(
+        self,
+        name: str,
+        values
+    ) -> '_Uniforms':
+        """
+        Set the provided 'value' to the normal type
+        uniform with the given 'name'. Here you have
+        some examples of defined uniforms we can set
+        with this method:
+        - `uniform vec2 name;`
+
+        TODO: Is this example ok? I didn't use it yet
+        """
+        if name in self.program:
+            self.program[name].write(np.array(values, dtype = 'f4').tobytes())
+
+        return self
+
+    def set_mat(
+        self,
+        name: str,
+        value
+    ) -> '_Uniforms':
+        """
+        Set the provided 'value' to a `matN` type
+        uniform with the given 'name'. The 'value'
+        must be a NxN matrix (maybe numpy array)
+        transformed to bytes ('.tobytes()').
+        
+        This uniform must be defined in the vertex
+        like this:
+        - `uniform matN name;`
+
+        TODO: Maybe we can accept a NxN numpy 
+        array and do the .tobytes() by ourselves...
+        """
+        if name in self.program:
+            self.program[name].write(value)
+
+        return self
+    
+    def print(
+        self
+    ) -> '_Uniforms':
+        """
+        Print the defined uniforms in console.
+        """
+        for key, value in self.uniforms.items():
+            print(f'"{key}": {str(value)}')
+
+class OpenglNode(Node):
+    """
+    The basic class of a node to manipulate frames
+    as opengl textures. This node will process the
+    frame as an input texture and will generate 
+    also a texture as the output.
+
+    Nodes can be chained and the result from one
+    node can be applied on another node.
+    """
+
+    @property
+    @abstractmethod
+    def vertex_shader(
+        self
+    ) -> str:
+        """
+        The code of the vertex shader.
+        """
+        pass
+
+    @property
+    @abstractmethod
+    def fragment_shader(
+        self
+    ) -> str:
+        """
+        The code of the fragment shader.
+        """
+        pass
+
+    def __init__(
+        self,
+        context: moderngl.Context,
+        size: tuple[int, int],
+        **kwargs
+    ):
+        ParameterValidator.validate_mandatory_instance_of('context', context, moderngl.Context)
+        # TODO: Validate size
+
+        self.context: moderngl.Context = context
+        """
+        The context of the program.
+        """
+        self.size: tuple[int, int] = size
+        """
+        The size we want to use for the frame buffer
+        in a (width, height) format.
+        """
+        # Compile shaders within the program
+        self.program: moderngl.Program = self.context.program(
+            vertex_shader = self.vertex_shader,
+            fragment_shader = self.fragment_shader
+        )
+
+        # Create the fullscreen quad
+        self.quad = get_fullscreen_quad_vao(
+            context = self.context,
+            program = self.program
+        )
+
+        # Create the output fbo
+        self.output_tex = self.context.texture(self.size, 4)
+        self.output_tex.filter = (moderngl.LINEAR, moderngl.LINEAR)
+        self.fbo = self.context.framebuffer(color_attachments = [self.output_tex])
+
+        self.uniforms: _Uniforms = _Uniforms(self.program)
+        """
+        Shortcut to the uniforms functionality.
+        """
+        # Auto set uniforms dynamically if existing
+        for key, value in kwargs.items():
+            self.uniforms.set(key, value)
+
+    def process(
+        self,
+        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray']
+    ) -> moderngl.Texture:
+        """
+        Apply the shader to the 'input', that
+        must be a frame or a texture, and return
+        the new resulting texture.
+
+        We use and return textures to maintain
+        the process in GPU and optimize it.
+        """
+        if PythonValidator.is_instance_of(input, ['VideoFrame', 'ndarray']):
+            # TODO: What about the numpy format (?)
+            input = frame_to_texture(input, self.context)
+
+        self.fbo.use()
+        self.context.clear(0.0, 0.0, 0.0, 0.0)
+
+        input.use(location = 0)
+
+        if 'texture' in self.program:
+            self.program['texture'] = 0
+
+        self.quad.render()
+
+        return self.output_tex
+    
+class WavingNode(OpenglNode):
+    """
+    Just an example, without the shaders code
+    actually, to indicate that we can use
+    custom parameters to make it work.
+    """
+
+    @property
+    def vertex_shader(
+        self
+    ) -> str:
+        return (
+            '''
+            #version 330
+            in vec2 in_vert;
+            in vec2 in_texcoord;
+            out vec2 v_uv;
+            void main() {
+                v_uv = in_texcoord;
+                gl_Position = vec4(in_vert, 0.0, 1.0);
+            }
+            '''
+        )
+
+    @property
+    def fragment_shader(
+        self
+    ) -> str:
+        return (
+            '''
+            #version 330
+            uniform sampler2D tex;
+            uniform float time;
+            uniform float amplitude;
+            uniform float frequency;
+            uniform float speed;
+            in vec2 v_uv;
+            out vec4 f_color;
+            void main() {
+                float wave = sin(v_uv.x * frequency + time * speed) * amplitude;
+                vec2 uv = vec2(v_uv.x, v_uv.y + wave);
+                f_color = texture(tex, uv);
+            }
+            '''
+        )
+
+    def __init__(
+        self,
+        context: moderngl.Context,
+        size: tuple[int, int],
+        amplitude: float = 0.05,
+        frequency: float = 10.0,
+        speed: float = 2.0
+    ):
+        super().__init__(
+            context = context,
+            size = size,
+            amplitude = amplitude,
+            frequency = frequency,
+            speed = speed
+        )
+
+    # This is just an example and we are not
+    # using the parameters actually, but we
+    # could set those specific uniforms to be
+    # processed by the code
+    def process(
+        self,
+        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        t: float = 0.0,
+    ) -> moderngl.Texture:
+        """
+        Apply the shader to the 'input', that
+        must be a frame or a texture, and return
+        the new resulting texture.
+
+        We use and return textures to maintain
+        the process in GPU and optimize it.
+        """
+        self.uniforms.set('time', t)
+
+        return super().process(input)

yta_video_opengl/reader/__init__.py

@@ -398,9 +398,14 @@ class VideoReader:
         """
         The stream that includes the audio.
         """
-        self.cache: VideoFrameCache = None
+        self.video_cache: VideoFrameCache = None
         """
-        The frame cache system to optimize
+        The video frame cache system to optimize
+        the way we access to the frames.
+        """
+        self.audio_cache: VideoFrameCache = None
+        """
+        The audio frame cache system to optimize
         the way we access to the frames.
         """
 
@@ -434,7 +439,8 @@ class VideoReader:
             self.video_stream.thread_type = 'AUTO'
             self.audio_stream = self.container.streams.audio[0]
             self.audio_stream.thread_type = 'AUTO'
-            self.cache = VideoFrameCache(self)
+            self.video_cache = VideoFrameCache(self.container, self.video_stream)
+            self.audio_cache = VideoFrameCache(self.container, self.audio_stream)
 
     def seek(
         self,
@@ -564,10 +570,45 @@ class VideoReader:
         index: int
     ) -> 'VideoFrame':
         """
-        Get the frame with the given 'index', using
-        the cache system.
+        Get the video frame with the given 'index',
+        using the video cache system.
+        """
+        return self.video_cache.get_frame(index)
+    
+    # TODO: Will we use this (?)
+    def get_audio_frame(
+        self,
+        index: int
+    ) -> 'VideoFrame':
+        """
+        Get the audio frame with the given 'index',
+        using the audio cache system.
+        """
+        return self.video_cache.get_frame(index)
+    
+    def get_frames(
+        self,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
         """
-        return self.cache.get_frame(index)
+        Iterator to get the video frames in between
+        the provided 'start' and 'end' time moments.
+        """
+        for frame in self.video_cache.get_frames(start, end):
+            yield frame
+
+    def get_audio_frames(
+        self,
+        start: float = 0.0,
+        end: Union[float, None] = None
+    ):
+        """
+        Iterator to get the audio frames in between
+        the provided 'start' and 'end' time moments.
+        """
+        for frame in self.audio_cache.get_frames(start, end):
+            yield frame
     
     def close(
         self

yta_video_opengl/reader/cache.py

@@ -16,7 +16,16 @@ memory all those frames to be handled fast. It
 will remove the old frames if needed to use only
 the 'size' we set when creating it.
 """
+from yta_video_opengl.utils import t_to_pts, pts_to_t, pts_to_index
+from av.container import InputContainer
+from av.video.stream import VideoStream
+from av.audio.stream import AudioStream
+from av.video.frame import VideoFrame
+from av.audio.frame import AudioFrame
+from yta_validation.parameter import ParameterValidator
+from fractions import Fraction
 from collections import OrderedDict
+from typing import Union
 
 
 class VideoFrameCache:
@@ -26,33 +35,44 @@ class VideoFrameCache:
     """
 
     @property
-    def container(
+    def fps(
         self
-    ) -> 'InputContainer':
+    ) -> float:
         """
-        Shortcut to the video reader instance container.
+        The frames per second as a float.
         """
-        return self.reader_instance.container
+        return (
+            float(self.stream.average_rate)
+            if self.stream.type == 'video' else
+            float(self.stream.rate)
+        )
     
     @property
-    def stream(
+    def time_base(
         self
-    ) -> 'VideoStream':
+    ) -> Union[Fraction, None]:
         """
-        Shortcut to the video reader instance video
-        stream.
+        The time base of the stream.
         """
-        return self.reader_instance.video_stream
+        return self.stream.time_base
 
     def __init__(
         self,
-        reader: 'VideoReader',
+        container: InputContainer,
+        stream: Union[VideoStream, AudioStream],
         size: int = 50
     ):
-        self.reader_instance: 'VideoReader' = reader
+        ParameterValidator.validate_mandatory_instance_of('container', container, InputContainer)
+        ParameterValidator.validate_mandatory_instance_of('stream', stream, [VideoStream, AudioStream])
+        ParameterValidator.validate_mandatory_positive_int('size', size)
+
+        self.container: InputContainer = container
+        """
+        The pyav container.
         """
-        The video reader instance this cache belongs
-        to.
+        self.stream: Union[VideoStream, AudioStream] = stream
+        """
+        The pyav stream.
         """
         self.cache: OrderedDict = OrderedDict()
         """
@@ -69,21 +89,40 @@ class VideoFrameCache:
         end.
         """
 
+        self._prepare()
+
+    def _prepare(
+        self
+    ):
         # Index key frames
         for packet in self.container.demux(self.stream):
             if packet.is_keyframe:
                 self.key_frames_pts.append(packet.pts)
 
         self.container.seek(0)
-        # TODO: Maybe this is better (?)
-        #self.reader_instance.reset()
+
+    def _get_nearest_keyframe_fps(
+        self,
+        pts: int
+    ):
+        """
+        Get the fps of the keyframe that is the
+        nearest to the provided 'pts'. Useful to
+        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
+        ])
 
     def _get_frame_by_pts(
         self,
-        target_pts
+        pts: int
     ):
         """
-        Get the frame that has the provided 'target_pts'.
+        Get the frame that has the provided 'pts'.
 
         This method will start decoding frames from the
         most near key frame (the one with the nearer
@@ -94,11 +133,7 @@ class VideoFrameCache:
         requested is not stored in the caché.
         """
         # Look for the most near key frame
-        key_frame_pts = max([
-            key_frame_pts
-            for key_frame_pts in self.key_frames_pts
-            if key_frame_pts <= target_pts
-        ])
+        key_frame_pts = self._get_nearest_keyframe_fps(pts)
 
         # Go to the key frame that includes it
         self.container.seek(key_frame_pts, stream = self.stream)
@@ -106,21 +141,20 @@ class VideoFrameCache:
         decoded = None
         for frame in self.container.decode(self.stream):
             # TODO: Could 'frame' be None (?)
-            pts = frame.pts
-            if pts is None:
+            if frame.pts is None:
                 continue
 
             # Store in cache if needed
-            if pts not in self.cache:
+            if frame.pts not in self.cache:
                 # TODO: The 'format' must be dynamic
-                self.cache[pts] = frame.to_ndarray(format = "rgb24")
+                self.cache[frame.pts] = frame.to_ndarray(format = "rgb24")
 
                 # Clean cache if full
                 if len(self.cache) > self.size:
                     self.cache.popitem(last = False)
 
-            if pts >= target_pts:
-                decoded = self.cache[pts]
+            if frame.pts >= pts:
+                decoded = self.cache[frame.pts]
                 break
 
         return decoded
@@ -128,21 +162,65 @@ class VideoFrameCache:
     def get_frame(
         self,
         index: int
-    ) -> 'VideoFrame':
+    ) -> Union[VideoFrame, AudioFrame]:
         """
         Get the frame with the given 'index' from
         the cache.
         """
-        # convertir frame_number a PTS (timestamps internos)
-        time_base = self.stream.time_base
-        fps = float(self.stream.average_rate)
-        target_pts = int(index / fps / time_base)
+        # TODO: Maybe we can accept 't' and 'pts' also
+        target_pts = int(index / self.fps / self.time_base)
 
         return (
             self.cache[target_pts]
             if target_pts in self.cache else
             self._get_frame_by_pts(target_pts)
         )
+
+    def get_frames(
+        self,
+        start: float = 0,
+        end: Union[float, None] = None
+    ):
+        """
+        Get all the frames in the range between
+        the provided 'start' and 'end' time in
+        seconds.
+        """
+        # TODO: I create this method by default using
+        # the cache. Think about how to implement it
+        # and apply it here, please.
+        # Go to the nearest key frame
+        start = t_to_pts(start, self.time_base)
+        end = (
+            t_to_pts(end, self.time_base)
+            if end is not None else
+            None
+        )
+        key_frame_pts = self._get_nearest_keyframe_fps(start)
+
+        # Go to the nearest key frame to start decoding
+        self.container.seek(key_frame_pts, stream = self.stream)
+
+        for packet in self.container.demux(self.stream):
+            for frame in packet.decode():
+                if frame.pts is None:
+                    continue
+
+                if frame.pts < start:
+                    continue
+
+                if (
+                    end is not None and
+                    frame.pts > end
+                ):
+                    return
+                
+                # TODO: Maybe send a @dataclass instead (?)
+                yield (
+                    frame,
+                    pts_to_t(frame.pts, self.time_base),
+                    pts_to_index(frame.pts, self.time_base, self.fps)
+                )
     
     def clear(
         self

yta_video_opengl/tests.py

@@ -583,7 +583,7 @@ def video_modified_stored():
     from yta_video_opengl.utils import texture_to_frame, frame_to_texture
     from yta_video_opengl.video import Video
 
-    Video(VIDEO_PATH, 0, 0.5).save_as(OUTPUT_PATH)
+    Video(VIDEO_PATH, 0.25, 0.75).save_as(OUTPUT_PATH)
 
     return
 

yta_video_opengl/video.py

@@ -22,6 +22,9 @@ class Video:
         """
         The start packet time stamp (pts), needed 
         to optimize the packet iteration process.
+
+        This timestamp is used to read the video
+        file source.
         """
         return int(self.start / self.reader.time_base)
     
@@ -32,6 +35,9 @@ class Video:
         """
         The end packet time stamp (pts), needed to
         optimize the packet iteration process.
+
+        This timestamp is used to read the video
+        file source.
         """
         return (
             int(self.end / self.reader.time_base)
@@ -73,6 +79,15 @@ class Video:
         The duration of the video.
         """
         return self.end - self.start
+    
+    @property
+    def number_of_frames(
+        self
+    ):
+        """
+        The number of frames of the video.
+        """
+        return self.reader.number_of_frames
 
     @property
     def frames(
@@ -84,20 +99,19 @@ class Video:
         'start' and 'end' parameters provided when
         instantiating it.
 
+        The iterator will iterate first over the
+        video frames, and once finished over the
+        audio frames.
+
         This method returns a tuple of 3 elements:
         - `frame` as a `VideoFrame` instance
         - `t` as the frame time moment
         - `index` as the frame index
         """
-        for frame in iterate_stream_frames_demuxing(
-            container = self.reader.container,
-            video_stream = self.reader.video_stream,
-            audio_stream = self.reader.audio_stream,
-            video_start_pts = self.start_pts,
-            video_end_pts = self.end_pts,
-            audio_start_pts = self.audio_start_pts,
-            audio_end_pts = self.audio_end_pts
-        ):
+        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__(
@@ -137,25 +151,46 @@ class Video:
         filename: str
     ) -> 'Video':
         writer =  VideoWriter(filename)
-        #writer.set_video_stream(self.reader.video_stream.codec.name, self.reader.fps, self.reader.size, PIXEL_FORMAT)
         writer.set_video_stream_from_template(self.reader.video_stream)
         writer.set_audio_stream_from_template(self.reader.audio_stream)
 
-        # TODO: I need to process the audio also, so
-        # build a method that do the same but for 
-        # both streams at the same time
+        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)
 

{yta_video_opengl-0.0.8.dist-info → yta_video_opengl-0.0.10.dist-info}/METADATA

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

yta_video_opengl-0.0.10.dist-info/RECORD

@@ -0,0 +1,16 @@
+yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
+yta_video_opengl/classes.py,sha256=t5-Tfc7ecvHl8JlVBp_FVzZT6ole6Ly5-FeBBH7wcxo,37742
+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=rAWISZ7OzDnzar0At-LCfDA-MmWzax2jT2l5gySv4aw,16911
+yta_video_opengl/reader/cache.py,sha256=UKhZvgY80ySuOYH52ikco6affsm8bjP656EroVR9Utg,6960
+yta_video_opengl/tests.py,sha256=NZ-W1ak-ygwL9wATzEXtlCeCZX74ij_TZhktetMnOD4,25810
+yta_video_opengl/utils.py,sha256=y0N1mS9FjpB4nFnx00K7sIs5EsqMkTe8C0bzLXZe9YM,10479
+yta_video_opengl/video.py,sha256=3n7jgZab7PUSOpODoaH4iNg0sy7NMRo_OaJ4Zj8u0NM,5855
+yta_video_opengl/writer.py,sha256=7xglz8xHOXMtWkctzuB21Y-e9xWFXYcklt3jVUN4svQ,8198
+yta_video_opengl-0.0.10.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
+yta_video_opengl-0.0.10.dist-info/METADATA,sha256=YZ81GUO5J78iri9e_GdjUXafQqjEyohcVjwAuknXGhU,671
+yta_video_opengl-0.0.10.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
+yta_video_opengl-0.0.10.dist-info/RECORD,,

yta_video_opengl-0.0.8.dist-info/RECORD

@@ -1,12 +0,0 @@
-yta_video_opengl/__init__.py,sha256=ycAx_XYMVDfkuObSvtW6irQ0Wo-fgxEz3fjIRMe8PpY,205
-yta_video_opengl/classes.py,sha256=VUw73kfz8kxYLE0x0LxNHqFekF3CklcyofCNN-z57Lg,37706
-yta_video_opengl/reader/__init__.py,sha256=95thY3A2_QOPdKInQIN7eOlxwzZanFNi5yePmlsvdXc,15620
-yta_video_opengl/reader/cache.py,sha256=Y3lQrirQJz7zFeiJQeJnkzyghYeMahkpKzsouzB90VI,4421
-yta_video_opengl/tests.py,sha256=h_7juB8iV-pUj9EUMO_zzPZGj2IGIe60lK7xskI2n9I,25806
-yta_video_opengl/utils.py,sha256=y0N1mS9FjpB4nFnx00K7sIs5EsqMkTe8C0bzLXZe9YM,10479
-yta_video_opengl/video.py,sha256=xPlWP6ulTKsTqJd_7SwudAGUPFNOS6Hr6IRntdAvfx4,4966
-yta_video_opengl/writer.py,sha256=7xglz8xHOXMtWkctzuB21Y-e9xWFXYcklt3jVUN4svQ,8198
-yta_video_opengl-0.0.8.dist-info/LICENSE,sha256=6kbiFSfobTZ7beWiKnHpN902HgBx-Jzgcme0SvKqhKY,1091
-yta_video_opengl-0.0.8.dist-info/METADATA,sha256=LBw62abHLEFbp1x2bFcqs9CNCmr0a16pQ_UsvlFta2E,670
-yta_video_opengl-0.0.8.dist-info/WHEEL,sha256=XbeZDeTWKc1w7CSIyre5aMDU_-PohRwTQceYnisIYYY,88
-yta_video_opengl-0.0.8.dist-info/RECORD,,