yta-video-opengl 0.0.22__tar.gz → 0.0.24__tar.gz

{yta_video_opengl-0.0.22 → yta_video_opengl-0.0.24}/PKG-INFO

@@ -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.22 → yta_video_opengl-0.0.24}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "yta-video-opengl"
-version = "0.0.22"
+version = "0.0.24"
 description = "Youtube Autonomous Video OpenGL Module"
 authors = [
     {name = "danialcala94",email = "danielalcalavalera@gmail.com"}
@@ -9,16 +9,11 @@ readme = "README.md"
 requires-python = "==3.9"
 dependencies = [
     "yta_validation (>=0.0.1,<1.0.0)",
-    "yta_video_frame_time (>=0.0.1,<1.0.0)",
-    "yta_timer (>0.0.1,<1.0.0)",
-    "av (>=0.0.1,<19.0.0)",
+    "yta_programming (>=0.0.1,<1.0.0)",
     "moderngl (>=0.0.1,<9.0.0)",
     "numpy (>=0.0.1,<9.0.0)",
-    "quicktions (>=0.0.1,<9.0.0)",
-    # I need this 'pillow' just to read an image
-    # and transform into a numpy array to be able
-    # to handle the ImageMedia
-    "pillow (>=0.0.1,<99.0.0)"
+    # TODO: This below is just for testing
+    #"yta_video_pyav (>=0.0.1,<1.0.0)",
 ]
 
 [tool.poetry]

yta_video_opengl-0.0.24/src/yta_video_opengl/editor.py

@@ -0,0 +1,333 @@
+from yta_video_opengl.nodes.video.opengl import WavingNode
+from yta_video_opengl.nodes.audio import ChorusNode
+from yta_video_opengl.nodes import Node, TimedNode
+from yta_validation.parameter import ParameterValidator
+from yta_programming.decorators import singleton_old
+from typing import Union
+
+import moderngl
+
+
+class _AudioEffects:
+    """
+    *For internal use only*
+
+    The audio effects that will be available
+    throught our internal _Effects class to
+    wrap and make available all the audio
+    effects we want to be available.
+    """
+
+    def __init__(
+        self,
+        effects: '_Effects'
+    ):
+        self._effects: _Effects = effects
+        """
+        The parent instance that includes this
+        class instance as a property.
+        """
+
+    """
+    Here below we expose all the effects
+    we want the users to have available to
+    be used.
+    """
+    def chorus(
+        self,
+        sample_rate: int,
+        depth: int = 0,
+        frequency: float = 0.25,
+        start: Union[int, float, 'Fraction'] = 0,
+        end: Union[int, float, 'Fraction', None] = None
+    ):
+        return _create_node(
+            ChorusNode(
+                sample_rate = sample_rate,
+                depth = depth,
+                frequency = frequency
+            ),
+            start = start,
+            end = end
+        )
+    
+    # TODO: Include definitive and tested audio
+    # effects here below
+
+class _VideoEffects:
+    """
+    *For internal use only*
+
+    The video effects that will be available
+    throught our internal _Effects class to
+    wrap and make available all the video
+    effects we want to be available.
+    """
+
+    def __init__(
+        self,
+        effects: '_Effects'
+    ):
+        self._effects: _Effects = effects
+        """
+        The parent instance that includes this
+        class instance as a property.
+        """
+
+    """
+    Here below we expose all the effects
+    we want the users to have available to
+    be used.
+    """
+    def waving_node(
+        self,
+        # TODO: Maybe 'frame_size' (?)
+        size: tuple[int, int],
+        amplitude: float = 0.05,
+        frequency: float = 10.0,
+        speed: float = 2.0,
+        start: Union[int, float, 'Fraction'] = 0.0,
+        end: Union[int, float, 'Fraction', None] = None
+    ) -> 'TimedNode':
+        """
+        TODO: Explain this better.
+
+        The 'start' and 'end' time moments are the
+        limits of the time range in which the effect
+        has to be applied to the frames inside that
+        time range. Providing start=0 and end=None
+        will make the effect to be applied to any
+        frame.
+        """
+        return _create_node(
+            WavingNode(
+                context = self._effects._opengl_editor.context,
+                size = size,
+                amplitude = amplitude,
+                frequency = frequency,
+                speed = speed
+            ),
+            start = start,
+            end = end
+        )
+    
+    # TODO: Include definitive and tested video
+    # effects here below
+
+class _Effects:
+    """
+    *For internal use only*
+
+    Class to be used within the OpenglEditor
+    as a property to simplify the access to
+    the effect nodes and also to have the
+    single context always available through
+    the OpenglEditor instance that is a 
+    singleton one.
+
+    Even though we can have more effects,
+    this class is also the way we expose only
+    the ones we actually want to expose to 
+    the user.
+    """
+    
+    def __init__(
+        self,
+        opengl_editor: 'OpenglEditor'
+    ):
+        self._opengl_editor: OpenglEditor = opengl_editor
+        """
+        The parent instance that includes this
+        class instance as a property.
+        """
+        self.audio: _AudioEffects = _AudioEffects(self)
+        """
+        Shortcut to the audio effects that are
+        available.
+        """
+        self.video: _VideoEffects = _VideoEffects(self)
+        """
+        Shortcut to the video effects that are
+        available.
+        """
+
+@singleton_old
+class OpenglEditor:
+    """
+    Singleton instance.
+
+    It is a singleton instance to have a
+    unique context for all the instances
+    that need it and instantiate this
+    class to obtain it. Here we group all
+    the nodes we have available for the
+    user.
+
+    The GPU will make the calculations in
+    parallel by itself, so we can handle a
+    single context to make the nodes share
+    textures and buffers.
+    """
+
+    def __init__(
+        self
+    ):
+        self.context = moderngl.create_context(standalone = True)
+        """
+        The context that will be shared by all
+        the nodes.
+        """
+        self.effects: _Effects = _Effects(self)
+        """
+        Shortcut to the effects.
+        """
+        # TODO: I should do something like
+        # editor.effects.waving_node() to create
+        # an instance of that effect node
+
+
+def _create_node(
+    node: Union['_AudioNode', '_VideoNode'],
+    start: Union[int, float, 'Fraction'],
+    end: Union[int, float, 'Fraction', None]
+):
+    # The class we pass has to inherit from this
+    # 'Node' class, but could be other classes
+    # in the middle, because an OpenglNode 
+    # inherits from other class
+    ParameterValidator.validate_mandatory_subclass_of('node', node, ['_AudioNode', '_VideoNode'])
+
+    # We have to create a Node wrapper with the
+    # time range in which it has to be applied
+    # to all the frames.
+    return TimedNode(
+        node = node,
+        start = start,
+        end = end
+    )
+
+class _EffectStacked:
+    """
+    Class to wrap an effect that will be
+    stacked with an specific priority.
+
+    Priority is higher when lower value,
+    and lower when higher value.
+    """
+
+    def __init__(
+        self,
+        effect: TimedNode,
+        priority: int
+    ):
+        self.effect: TimedNode = effect
+        """
+        The effect to be applied.
+        """
+        self.priority: int = priority
+        """
+        The priority this stacked frame has versus
+        the other stacked effects.
+        """
+
+# TODO: Move to another py file (?)
+class EffectsStack:
+    """
+    Class to include a collection of effects
+    we want to apply in some entity, that 
+    will make easier to apply them.
+
+    You can use this stack to keep the effects
+    you want to apply on a Media or on the
+    Timeline of your video editor.
+    """
+
+    @property
+    def effects(
+        self
+    ) -> list[_EffectStacked]:
+        """
+        The effects but ordered from their 'start'
+        time moment.
+        """
+        return sorted(self._effects, key = lambda effect: (effect.priority, effect.effect.start))
+    
+    @property
+    def most_priority_effect(
+        self
+    ) -> _EffectStacked:
+        """
+        The effect with the highest priority,
+        that is the lower priority value.
+        """
+        return min(self._effects, key = lambda effect: effect.priority)
+
+    @property
+    def less_priority_effect(
+        self
+    ) -> _EffectStacked:
+        """
+        The effect with the lowest priority,
+        that is the biggest priority value.
+        """
+        return max(self._effects, key = lambda effect: effect.priority)
+    
+    def __init__(
+        self
+    ):
+        self._effects: list[_EffectStacked] = []
+        """
+        A list containing all the effects that
+        have been added to this stack, unordered.
+        """
+
+    def get_effects_for_t(
+        self,
+        t: Union[int, float, 'Fraction']
+    ) -> list[TimedNode]:
+        """
+        Get the effects, ordered by priority
+        and the 'start' field, that must be
+        applied within the 't' time moment 
+        provided because it is within the
+        [start, end) time range.
+        """
+        return [
+            effect.effect
+            for effect in self.effects
+            if effect.effect.is_within_time(t)
+        ]
+
+    def add_effect(
+        self,
+        effect: TimedNode,
+        priority: Union[int, None] = None
+    ) -> 'EffectsStack':
+        """
+        Add the provided 'effect' to the stack.
+        """
+        ParameterValidator.validate_mandatory_instance_of('effect', effect, TimedNode)
+
+        # TODO: What about the same effect added
+        # twice during the same time range? Can we
+        # allow it? It will be applied twice for
+        # specific 't' time moments but with 
+        # different attributes. is it ok (?)
+
+        # TODO: What if priority is already taken?
+        # Should we let some effects have the same
+        # priority (?)
+        priority = (
+            self.less_priority_effect.priority + 1
+            if priority is None else
+            priority
+        )
+
+        self._effects.append(_EffectStacked(
+            effect = effect,
+            priority = priority
+        ))
+
+        return self
+    
+    # TODO: Create 'remove_effect'

{yta_video_opengl-0.0.22 → yta_video_opengl-0.0.24}/src/yta_video_opengl/nodes/__init__.py

@@ -1,31 +1,11 @@
+from yta_video_opengl.nodes.video import _VideoNode
+from yta_video_opengl.nodes.audio import _AudioNode
 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
@@ -54,9 +34,9 @@ class TimedNode:
 
     def __init__(
         self,
-        node: Node,
-        start: float = 0.0,
-        end: Union[float, None] = None
+        node: Union[_VideoNode, _AudioNode],
+        start: Union[int, float, 'Fraction'] = 0.0,
+        end: Union[int, float, 'Fraction', None] = None
     ):
         ParameterValidator.validate_mandatory_positive_number('start', start, do_include_zero = True)
         ParameterValidator.validate_positive_number('end', end, do_include_zero = False)
@@ -84,6 +64,28 @@ class TimedNode:
         stop being applied (excluding it).
         """
 
+    def _get_t(
+        self,
+        t: Union[int, float, 'Fraction']
+    ) -> float:
+        """
+        Obtain the 't' time moment relative to the
+        effect duration.
+
+        Imagine `start=3` and `end=5`, and we receive 
+        a `t=4`. It is inside the range, so we have
+        to apply the effect, but as the effect
+        lasts from second 3 to second 5 (`duration=2`),
+        the `t=4` is actually a `t=1` for the effect
+        because it is the time elapsed since the
+        effect started being applied, that was on the 
+        second 3.
+
+        The formula:
+        - `t - self.start`
+        """
+        return t - self.start
+
     def is_within_time(
         self,
         t: float
@@ -91,7 +93,9 @@ class TimedNode:
         """
         Flag to indicate if the 't' time moment provided
         is in the range of this TimedNode instance, 
-        which means that it fits this condition:
+        which means between the 'start' and the 'end'.
+
+        The formula:
         - `start <= t < end`
         """
         return (
@@ -102,7 +106,7 @@ class TimedNode:
 
     def process(
         self,
-        frame: Union[av.VideoFrame, av.AudioFrame, moderngl.Texture],
+        frame: Union['VideoFrame', 'AudioFrame', moderngl.Texture],
         t: float
         # TODO: Maybe we need 'fps' and 'number_of_frames'
         # to calculate progressions or similar...
@@ -113,7 +117,7 @@ class TimedNode:
         instance.
         """
         return (
-            self.node.process(frame, t)
+            self.node.process(frame, self._get_t(t))
             if self.is_within_time(t) else
             frame
         )

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

@@ -0,0 +1,224 @@
+"""
+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
+
+
+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