yta-video-opengl 0.0.25__tar.gz → 0.0.27__tar.gz

{yta_video_opengl-0.0.25 → yta_video_opengl-0.0.27}/PKG-INFO

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

{yta_video_opengl-0.0.25 → yta_video_opengl-0.0.27}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.25"
+version = "0.0.27"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}

{yta_video_opengl-0.0.25 → yta_video_opengl-0.0.27}/src/yta_video_opengl/effects.py

@@ -1,7 +1,9 @@
 from yta_video_opengl.nodes.video.opengl import WavingNode
 from yta_video_opengl.nodes.audio import ChorusNode
 from yta_video_opengl.nodes import TimedNode
+from yta_video_opengl.utils import texture_to_frame
 from yta_validation.parameter import ParameterValidator
+from yta_validation import PythonValidator
 from yta_programming.decorators import singleton_old
 from typing import Union
 
@@ -379,4 +381,46 @@ class EffectsStack:
 
         return self
     
+    def apply_video_effects(
+        self,
+        frame: 'np.ndarray',
+        t: Union[int, float, 'Fraction']
+    ) -> 'np.ndarray':
+        """
+        Apply all the video effects that must be
+        applied for the given 't' time moment to
+        the provided 'frame' (that must be the
+        video frame of that time moment).
+        """
+        for effect in self.get_video_effects_for_t(t):
+            frame = effect.process(frame, t)
+
+        # TODO: Check when the frame comes as a
+        # Texture and when as a numpy array. I
+        # think when we apply an opengl node it
+        # is a texture, but we need to return it
+        # as a numpy, always
+        return (
+            texture_to_frame(frame)
+            if PythonValidator.is_instance_of(frame, moderngl.Texture) else
+            frame
+        )
+    
+    def apply_audio_effects(
+        self,
+        frame: 'np.ndarray',
+        t: Union[int, float, 'Fraction']
+    ) -> 'np.ndarray':
+        """
+        Apply all the video effects that must be
+        applied for the given 't' time moment to
+        the provided 'frame' (that must be the
+        audio frame of that time moment).
+        """
+        for effect in self.get_audio_effects_for_t(t):
+            frame = effect.process(frame, t)
+
+        # Frame can only by a numpy array here
+        return frame
+    
     # TODO: Create 'remove_effect'

{yta_video_opengl-0.0.25 → yta_video_opengl-0.0.27}/src/yta_video_opengl/nodes/__init__.py

@@ -131,11 +131,11 @@ class TimedNode:
 
     def process(
         self,
-        frame: Union['VideoFrame', 'AudioFrame', moderngl.Texture],
+        frame: Union[moderngl.Texture, 'np.ndarray'],
         t: float
         # TODO: Maybe we need 'fps' and 'number_of_frames'
         # to calculate progressions or similar...
-    ) -> Union['VideoFrame', 'AudioFrame', 'Texture']:
+    ) -> Union[moderngl.Texture, 'np.ndarray']:
         """
         Process the frame if the provided 't' time
         moment is in the range of this TimedNode

yta_video_opengl-0.0.27/src/yta_video_opengl/nodes/audio/__init__.py

@@ -0,0 +1,133 @@
+"""
+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 abc import abstractmethod
+from typing import Union
+
+import numpy as np
+
+
+class _AudioNode:
+    """
+    Base audio node class to implement a
+    change in an audio frame by using the
+    numpy library.
+    """
+
+    @abstractmethod
+    def process(
+        self,
+        input: np.ndarray,
+        t: float
+    ) -> np.ndarray:
+        """
+        Process the provided audio 'input' that
+        is played on the given 't' time moment.
+        """
+        pass
+
+class VolumeNode(_AudioNode):
+    """
+    Set the volume.
+
+    TODO: Explain properly.
+    """
+
+    def __init__(
+        self,
+        factor_fn
+    ):
+        """
+        factor_fn: function (t, index) -> factor volumen
+        """
+        self.factor_f: callable = factor_fn
+
+    def process(
+        self,
+        input: np.ndarray,
+        t: float
+    ) -> np.ndarray:
+        """
+        Process the provided audio 'input' that
+        is played on the given 't' time moment.
+        """
+        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)
+        # )
+
+        return samples
+    
+class ChorusNode(_AudioNode):
+    """
+    Apply a chorus effect, also called flanger
+    effect.
+
+    TODO: Explain properly
+    """
+
+    def __init__(
+        self,
+        sample_rate: int,
+        depth: int = 0,
+        frequency: float = 0.25
+    ):
+        """
+        The 'sample_rate' must be the sample rate
+        of the audio frame.
+        """
+        self.sample_rate: int = sample_rate
+        self.depth: int = depth
+        self.frequency: float = frequency
+
+    def process(
+        self,
+        input: Union[np.ndarray],
+        t: float
+    ) -> np.ndarray:
+        """
+        Process the provided audio 'input' that
+        is played on the given 't' time moment.
+        """
+        n_samples = input.shape[0]
+        t = np.arange(n_samples) / self.rate
+
+        # 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]
+
+            output[i]= (
+                0.7 * input[i] + 0.7 * input[i - d]
+                if (i - d) >= 0 else
+                input[i]
+            )
+
+        return output

{yta_video_opengl-0.0.25 → yta_video_opengl-0.0.27}/src/yta_video_opengl/nodes/video/opengl/__init__.py

@@ -199,7 +199,7 @@ class OpenglNodeBase(_VideoNode):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray']
+        input: Union[moderngl.Texture, np.ndarray]
     ) -> moderngl.Texture:
         """
         Apply the shader to the 'input', that
@@ -209,7 +209,7 @@ class OpenglNodeBase(_VideoNode):
         We use and return textures to maintain
         the process in GPU and optimize it.
         """
-        if PythonValidator.is_instance_of(input, ['VideoFrame', 'ndarray']):
+        if PythonValidator.is_instance_of(input, np.ndarray):
             # TODO: What about the numpy format (?)
             input = frame_to_texture(input, self.context)
 
@@ -293,7 +293,7 @@ class WavingNode(OpenglNodeBase):
     # processed by the code
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, 'np.ndarray'],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """

{yta_video_opengl-0.0.25 → yta_video_opengl-0.0.27}/src/yta_video_opengl/nodes/video/opengl/experimental.py

@@ -65,7 +65,7 @@ class BreathingFrame(OpenglNodeBase):
     
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, 'np.ndarray'],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -165,7 +165,7 @@ class HandheldFrame(OpenglNodeBase):
     
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -351,7 +351,7 @@ class OrbitingFrame(OpenglNodeBase):
     
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -446,7 +446,7 @@ class RotatingInCenterFrame(OpenglNodeBase):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -636,7 +636,7 @@ class StrangeTvFrame(OpenglNodeBase):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """
@@ -744,7 +744,7 @@ class GlitchRgbFrame(OpenglNodeBase):
 
     def process(
         self,
-        input: Union[moderngl.Texture, 'VideoFrame', 'np.ndarray'],
+        input: Union[moderngl.Texture, np.ndarray],
         t: float = 0.0,
     ) -> moderngl.Texture:
         """

yta_video_opengl-0.0.25/src/yta_video_opengl/nodes/audio/__init__.py

@@ -1,223 +0,0 @@
-"""
-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 abc import abstractmethod
-from typing import Union
-
-import numpy as np
-
-
-class _AudioNode:
-    """
-    Base audio node class to implement a
-    change in an audio frame by using the
-    numpy library.
-    """
-
-    @abstractmethod
-    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.
-        """
-        pass
-
-class VolumeNode(_AudioNode):
-    """
-    Set the volume.
-
-    TODO: Explain properly.
-    """
-
-    def __init__(
-        self,
-        factor_fn
-    ):
-        """
-        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)
-
-        # 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):
-    """
-    Apply a chorus effect, also called flanger
-    effect.
-
-    TODO: Explain properly
-    """
-
-    def __init__(
-        self,
-        sample_rate: int,
-        depth: int = 0,
-        frequency: float = 0.25
-    ):
-        """
-        The 'sample_rate' must be the sample rate
-        of the audio frame.
-        """
-        self.sample_rate: int = sample_rate
-        self.depth: int = depth
-        self.frequency: float = frequency
-
-    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.
-        """
-        # TODO: I think we should receive only 
-        # numpy arrays and the AudioFrame should
-        # be handled outside, but I'm not sure
-
-        n_samples = input.shape[0]
-        t = np.arange(n_samples) / self.rate
-
-        # 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