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

yta_video_opengl/nodes/audio/__init__.py

@@ -16,15 +16,13 @@ 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:
+class _AudioNode:
     """
     Base audio node class to implement a
     change in an audio frame by using the
@@ -34,82 +32,192 @@ class AudioNode:
     @abstractmethod
     def process(
         self,
-        frame: av.AudioFrame,
+        input: Union['AudioFrame', 'np.ndarray'],
         t: float
-    ):
+    ) -> Union['AudioFrame', 'np.ndarray']:
         """
-        Process the provided audio 'frame' that
+        Process the provided audio 'input' 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):
+class VolumeNode(_AudioNode):
     """
-    TimedNode to set the audio volume of a video
-    in a specific frame.
+    Set the volume.
+
+    TODO: Explain properly.
     """
 
     def __init__(
         self,
-        factor_fn,
-        start: float = 0.0,
-        end: Union[float, None] = None
+        factor_fn
     ):
-        super().__init__(
-            node = _SetVolumeAudioNode(factor_fn),
-            start = start,
-            end = end
-        )
+        """
+        factor_fn: function (t, index) -> factor volumen
+        """
+        self.factor_f: callable = factor_fn
+
+    def process(
+        self,
+        input: Union['AudioFrame', 'np.ndarray'],
+        t: float
+    ) -> Union['AudioFrame', 'np.ndarray']:
+        """
+        Process the provided audio 'input' that
+        is played on the given 't' time moment.
+        """
+        # if PythonValidator.is_instance_of(input, 'AudioFrame'):
+        #     input = input.to_ndarray().astype(np.float32)
 
-class _SetVolumeAudioNode(AudioNode):
+        # TODO: I think we should receive only 
+        # numpy arrays and the AudioFrame should
+        # be handled outside, but I'm not sure
+
+        factor = self.factor_fn(t, 0)
+
+        samples = input
+        samples *= factor
+
+        # Determine dtype according to format
+        # samples = (
+        #     samples.astype(np.int16)
+        #     # 'fltp', 's16', 's16p'
+        #     if 's16' in input.format.name else
+        #     samples.astype(np.float32)
+        # )
+
+        # new_frame = AudioFrame.from_ndarray(
+        #     samples,
+        #     format = input.format.name,
+        #     layout = input.layout.name
+        # )
+        # new_frame.sample_rate = input.sample_rate
+        # new_frame.pts = input.pts
+        # new_frame.time_base = input.time_base
+
+        return samples
+    
+class ChorusNode(_AudioNode):
     """
-    Audio node to change the volume of an
-    audio frame.
+    Apply a chorus effect, also called flanger
+    effect.
+
+    TODO: Explain properly
     """
 
     def __init__(
         self,
-        factor_fn
+        sample_rate: int,
+        depth: int = 0,
+        frequency: float = 0.25
     ):
         """
-        factor_fn: function (t, index) -> factor volumen
+        The 'sample_rate' must be the sample rate
+        of the audio frame.
         """
-        self.factor_fn = factor_fn
+        self.sample_rate: int = sample_rate
+        self.depth: int = depth
+        self.frequency: float = frequency
 
     def process(
         self,
-        frame: av.AudioFrame,
-        t: float,
-    ) -> av.AudioFrame:
-        # TODO: Why index (?) Maybe 'total_frames'
-        factor = self.factor_fn(t, 0)
+        input: Union['AudioFrame', 'np.ndarray'],
+        t: float
+    ) -> Union['AudioFrame', 'np.ndarray']:
+        """
+        Process the provided audio 'input' that
+        is played on the given 't' time moment.
+        """
+        # TODO: I think we should receive only 
+        # numpy arrays and the AudioFrame should
+        # be handled outside, but I'm not sure
 
-        samples = frame.to_ndarray().astype(np.float32)
-        samples *= factor
+        n_samples = input.shape[0]
+        t = np.arange(n_samples) / self.rate
 
-        # 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
+        # LFO sinusoidal que controla el retardo
+        delay = (self.depth / 1000.0) * self.rate * (0.5 * (1 + np.sin(2 * np.pi * self.frequency * t)))
+        delay = delay.astype(np.int32)
+
+        output = np.zeros_like(input, dtype=np.float32)
+
+        for i in range(n_samples):
+            d = delay[i]
+            if i - d >= 0:
+                output[i] = 0.7 * input[i] + 0.7 * input[i - d]
+            else:
+                output[i] = input[i]
+
+        return output
+
+# TODO: Remove this below
+"""
+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

@@ -2,4 +2,34 @@
 Working with video frames has to be done
 with nodes that use OpenGL because this
 way, by using the GPU, is the best way.
-"""
+"""
+from typing import Union
+from abc import ABC, abstractmethod
+
+import moderngl
+
+
+# TODO: Expose all the nodes here and move
+# this abstract to an abstract file (?)
+
+class _VideoNode(ABC):
+    """
+    Base abstract class to represent a video
+    node, which is an entity that processes
+    video frames individually.
+
+    This class must be inherited by any video
+    node class.
+    """
+
+    # TODO: What about the types?
+    # TODO: Should we expect pyav frames (?)
+    @abstractmethod
+    def process(
+        self,
+        frame: Union['VideoFrame', moderngl.Texture, 'np.ndarray'],
+        t: float
+        # TODO: Maybe we need 'fps' and 'number_of_frames'
+        # to calculate progressions or similar...
+    ) -> Union['VideoFrame', moderngl.Texture, 'np.ndarray']:
+        pass

yta_video_opengl/nodes/video/{opengl.py → opengl/__init__.py}

@@ -1,5 +1,5 @@
 from yta_video_opengl.utils import frame_to_texture, get_fullscreen_quad_vao
-from yta_video_opengl.nodes import Node
+from yta_video_opengl.nodes.video import _VideoNode
 from yta_validation.parameter import ParameterValidator
 from yta_validation import PythonValidator
 from abc import abstractmethod
@@ -123,7 +123,7 @@ class _Uniforms:
         for key, value in self.uniforms.items():
             print(f'"{key}": {str(value)}')
 
-class OpenglNode(Node):
+class OpenglNodeBase(_VideoNode):
     """
     The basic class of a node to manipulate frames
     as opengl textures. This node will process the
@@ -225,7 +225,7 @@ class OpenglNode(Node):
 
         return self.output_tex
     
-class WavingNode(OpenglNode):
+class WavingNode(OpenglNodeBase):
     """
     Just an example, without the shaders code
     actually, to indicate that we can use
@@ -306,4 +306,8 @@ class WavingNode(OpenglNode):
         """
         self.uniforms.set('time', t)
 
-        return super().process(input)
+        return super().process(input)
+    
+# TODO: Add more definitive effects
+
+