Merge branch 'org-master'

Author: belangeo

documentation/source/api/classes/pattern.rst

@@ -10,6 +10,7 @@ Objects in this category
 ------------------------------
 
 - :py:class:`CallAfter` :     Calls a Python function after a given time.
+- :py:class:`CallAlways` :     Calls a Python function every processing frame.
 - :py:class:`Pattern` :     Periodically calls a Python function.
 - :py:class:`Score` :     Calls functions by incrementation of a preformatted name.
 
@@ -21,6 +22,14 @@ Objects in this category
 
    .. autoclasstoc::
 
+*CallAlways*
+-----------------------------------
+
+.. autoclass:: CallAlways
+   :members:
+
+   .. autoclasstoc::
+
 *Pattern*
 -----------------------------------
 

include/pyomodule.h

@@ -95,6 +95,7 @@ typedef enum
     PYO_RUNTIME_TYPE_PATTERN,
     PYO_RUNTIME_TYPE_SCORE,
     PYO_RUNTIME_TYPE_CALLAFTER,
+    PYO_RUNTIME_TYPE_CALLALWAYS,
     PYO_RUNTIME_TYPE_M_SIN,
     PYO_RUNTIME_TYPE_M_COS,
     PYO_RUNTIME_TYPE_M_TAN,
@@ -442,6 +443,7 @@ PyTypeObject * PyoCreateOscListReceiverType(PyObject *module);
 PyTypeObject * PyoCreatePatternType(PyObject *module);
 PyTypeObject * PyoCreateScoreType(PyObject *module);
 PyTypeObject * PyoCreateCallAfterType(PyObject *module);
+PyTypeObject * PyoCreateCallAlwaysType(PyObject *module);
 PyTypeObject * PyoCreateMSinType(PyObject *module);
 PyTypeObject * PyoCreateMCosType(PyObject *module);
 PyTypeObject * PyoCreateMTanType(PyObject *module);
@@ -773,6 +775,7 @@ typedef Py_ssize_t T_SIZE_T;
 #define TYPE_F_FFF "f|fff"
 #define TYPE_O_FIFFI "O|fiffi"
 #define TYPE_O_F "O|f"
+#define TYPE_O_O "O|O"
 #define TYPE_O_FO "O|fO"
 #define TYPE_O_OIF "O|Oif"
 #define TYPE__OF "|Of"
@@ -869,6 +872,7 @@ typedef Py_ssize_t T_SIZE_T;
 #define TYPE_F_FFF "d|ddd"
 #define TYPE_O_FIFFI "O|diddi"
 #define TYPE_O_F "O|d"
+#define TYPE_O_O "O|O"
 #define TYPE_O_FO "O|dO"
 #define TYPE_O_OIF "O|Oid"
 #define TYPE__OF "|Od"

pyo/__init__.py

@@ -347,7 +347,7 @@
                     "Binaural",
                 ]
             ),
-            "pattern": sorted(["Pattern", "Score", "CallAfter"]),
+            "pattern": sorted(["Pattern", "Score", "CallAfter", "CallAlways"]),
             "randoms": sorted(
                 [
                     "Randi",

pyo/examples/x09-callbacks/04-process-calls.py

@@ -0,0 +1,56 @@
+"""
+04-process-calls.py - Calling python functions every processing frame
+
+This example shows two things:
+
+1. How to share memory from a PyoTableObject to a numpy array with the
+   `getBuffer()` method of the PyoTableObject. Numpy functions can then
+   be used to modify the table's content without copying every samples.
+
+2. How to call a python function every processing frame with the
+   CallAlways object.
+
+.. note::
+
+    The numpy module **must** be installed for this example to work.
+
+"""
+
+from pyo import *
+import numpy as np
+
+s = Server().boot()
+
+# Get the length of an audio block.
+bs = s.getBufferSize()
+
+# Create a table of length `buffer size`.
+t = DataTable(size=bs)
+
+# Share the table's memory with a numpy array.
+arr = np.asarray(t.getBuffer())
+
+def proc1():
+    "Fill the array (so the table) with white noise."
+    arr[:] = np.random.normal(0.0, 0.5, size=bs)
+
+# Fill the table.
+call1 = CallAlways(proc1)
+
+# You can do other pyo processes here (read the table, process the signal, feed into another shared table, etc.).
+
+# numpy filter's kernel.
+kernel_len = 32
+window = np.ones(kernel_len) / kernel_len
+
+def proc2():
+    "Lowpass filter the array content."
+    arr[:] = np.convolve(arr, window, mode='same')
+
+# Lowpass filter the table content.
+call2 = CallAlways(proc2) 
+
+# Read the table in loop.
+osc = TableRead(t, freq=t.getRate(), loop=True, mul=0.1).out()
+
+s.gui(locals())

pyo/lib/pattern.py

@@ -390,3 +390,96 @@ def arg(self):
     @arg.setter
     def arg(self, x):
         self.setArg(x)
+
+class CallAlways(PyoObject):
+    """
+    Calls a Python function every processing frame.
+
+    :Parent: :py:class:`PyoObject`
+
+    :Args:
+
+        function: Python callable (function or method)
+            Python callable executed every buffer size.
+        arg: any Python object, optional
+            Argument sent to the called function. Defaults to None.
+
+    .. note::
+
+        The out() method is bypassed. CallAlways doesn't return signal.
+
+        CallAlways has no `mul` and `add` attributes.
+
+        If `arg` is None, the function must be defined without argument:
+
+        >>> def tocall():
+        >>>     pass # function's body
+
+        If `arg` is not None, the function must be defined with one argument:
+
+        >>> def tocall(arg):
+        >>>     print(arg)
+
+    >>> s = Server().boot()
+    >>> s.start()
+    >>> t = DataTable(size=s.getBufferSize())
+    >>> n = Noise()
+    >>> f = TableFill(n, t)
+    >>> def callback(arg):
+    ...     # Apply a lowpass filter and a gain on the table content
+    ...     t.lowpass(arg)
+    ...     t.mul(0.25)
+    >>> a = CallAlways(callback, 500)
+    >>> o = TableScan(t).out()
+
+    """
+
+    def __init__(self, function, arg=None):
+        pyoArgsAssert(self, "c", function)
+        PyoObject.__init__(self)
+        self._function = getWeakMethodRef(function)
+        self._arg = arg
+        function, arg, lmax = convertArgsToLists(function, arg)
+        self._base_objs = [
+            CallAlways_base(WeakMethod(wrap(function, i)), wrap(arg, i))
+            for i in range(lmax)
+        ]
+        self._init_play()
+
+    def out(self, x=0, inc=1, dur=0, delay=0):
+        return self.play(dur, delay)
+
+    def setMul(self, x):
+        pass
+
+    def setAdd(self, x):
+        pass
+
+    def setSub(self, x):
+        pass
+
+    def setDiv(self, x):
+        pass
+
+    def setArg(self, x):
+        """
+        Replace the `arg` attribute.
+
+        :Args:
+
+            x: Anything
+                new `arg` attribute.
+
+        """
+        self._arg = x
+        x, lmax = convertArgsToLists(x)
+        [obj.setArg(wrap(x, i)) for i, obj in enumerate(self._base_objs)]
+
+    @property
+    def arg(self):
+        """Anything. Callable's argument."""
+        return self._arg
+
+    @arg.setter
+    def arg(self, x):
+        self.setArg(x)

src/engine/pyomodule.c

@@ -2522,6 +2522,8 @@ pyo_exec(PyObject *m)
         return -1;
     if (module_add_heap_object(m, "CallAfter_base", PyoCreateCallAfterType, PYO_RUNTIME_TYPE_CALLAFTER) < 0)
         return -1;
+    if (module_add_heap_object(m, "CallAlways_base", PyoCreateCallAlwaysType, PYO_RUNTIME_TYPE_CALLALWAYS) < 0)
+        return -1;
     if (module_add_heap_object(m, "BandSplitter_base", PyoCreateBandSplitterType, PYO_RUNTIME_TYPE_BANDSPLITTER) < 0)
         return -1;
     if (module_add_heap_object(m, "BandSplit_base", PyoCreateBandSplitType, PYO_RUNTIME_TYPE_BANDSPLIT) < 0)