pyo.lib.phasevoc — Pyo 1.0.4 documentation

Pyo 1.0.4 documentation

# Source code for pyo.lib.phasevoc

    """
    Phase vocoder.

    The phase vocoder is a digital signal processing technique of potentially
    great musical significance. It can be used to perform very high fidelity
    time scaling, pitch transposition, and myriad other modifications of sounds.

    """

    """
    Copyright 2009-2015 Olivier Belanger

    This file is part of pyo, a python module to help digital signal
    processing script creation.

    pyo is free software: you can redistribute it and/or modify
    it under the terms of the GNU Lesser General Public License as
    published by the Free Software Foundation, either version 3 of the
    License, or (at your option) any later version.

    pyo is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with pyo.  If not, see <http://www.gnu.org/licenses/>.
    """
    from ._core import *
    from ._maps import *
    from ._widgets import createSpectrumWindow
    from .pattern import Pattern

    class PVAnal(PyoPVObject):
        """
        Phase Vocoder analysis object.

        PVAnal takes an input sound and performs the phase vocoder
        analysis on it. This results in two streams, one for the bin's
        magnitudes and the other for the bin's true frequencies. These
        two streams are used by the PVxxx object family to transform
        the input signal using spectral domain algorithms. The last
        object in the phase vocoder chain must be a PVSynth to perform
        the spectral to time domain conversion.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoObject
                Input signal to process.
            size: int {pow-of-two > 4}, optional
                FFT size. Must be a power of two greater than 4.
                Defaults to 1024.

                The FFT size is the number of samples used in each
                analysis frame.
            overlaps: int, optional
                The number of overlaped analysis block. Must be a
                power of two. Defaults to 4.

                More overlaps can greatly improved sound quality
                synthesis but it is also more CPU expensive.
            wintype: int, optional
                Shape of the envelope used to filter each input frame.
                Possible shapes are:

                0. rectangular (no windowing)
                1. Hamming
                2. Hanning (default)
                3. Bartlett (triangular)
                4. Blackman 3-term
                5. Blackman-Harris 4-term
                6. Blackman-Harris 7-term
                7. Tuckey (alpha = 0.66)
                8. Sine (half-sine window)
            callback: callable, optional
                If not None (default), this function will be called with the result
                of the analysis at the end of every overlap. The function will
                receive two arguments, a list of floats for both the magnitudes
                and the frequencies. The signature is:

                    callback(magnitudes, frequencies)

                If you analyse a multi-channel signal, you should pass a list
                of callables, one per channel to analyse.

        >>> s = Server().boot()
        >>> s.start()
        >>> a = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=0.7)
        >>> pva = PVAnal(a, size=1024, overlaps=4, wintype=2)
        >>> pvs = PVSynth(pva).mix(2).out()

        """

        def __init__(self, input, size=1024, overlaps=4, wintype=2, callback=None):
            pyoArgsAssert(self, "oiiic", input, size, overlaps, wintype, callback)
            PyoPVObject.__init__(self)
            self._input = input
            self._size = size
            self._overlaps = overlaps
            self._wintype = wintype
            self._callback = callback
            self._in_fader = InputFader(input)
            in_fader, size, overlaps, wintype, callback, lmax = convertArgsToLists(
                self._in_fader, size, overlaps, wintype, callback
            )
            self._base_objs = [
                PVAnal_base(wrap(in_fader, i), wrap(size, i), wrap(overlaps, i), wrap(wintype, i), wrap(callback, i))
                for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x, fadetime=0.05):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoObject
                    New signal to process.
                fadetime: float, optional
                    Crossfade time between old and new input. Default to 0.05.

            """
            pyoArgsAssert(self, "oN", x, fadetime)
            self._input = x
            self._in_fader.setInput(x, fadetime)

        def setSize(self, x):
            """
            Replace the `size` attribute.

            :Args:

                x: int
                    new `size` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._size = x
            x, lmax = convertArgsToLists(x)
            [obj.setSize(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setOverlaps(self, x):
            """
            Replace the `overlaps` attribute.

            :Args:

                x: int
                    new `overlaps` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._overlaps = x
            x, lmax = convertArgsToLists(x)
            [obj.setOverlaps(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setWinType(self, x):
            """
            Replace the `wintype` attribute.

            :Args:

                x: int
                    new `wintype` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._wintype = x
            x, lmax = convertArgsToLists(x)
            [obj.setWinType(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setCallback(self, x):
            """
            Replace the `callback` attribute.

            :Args:

                x: callable
                    new `callback` attribute.

            """
            pyoArgsAssert(self, "c", x)
            self._callback = x
            x, lmax = convertArgsToLists(x)
            [obj.setCallback(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        @property
        def input(self):
            """PyoObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def size(self):
            """int. FFT size."""
            return self._size

        @size.setter
        def size(self, x):
            self.setSize(x)

        @property
        def overlaps(self):
            """int. FFT overlap factor."""
            return self._overlaps

        @overlaps.setter
        def overlaps(self, x):
            self.setOverlaps(x)

        @property
        def wintype(self):
            """int. Windowing method."""
            return self._wintype

        @wintype.setter
        def wintype(self, x):
            self.setWinType(x)

    class PVSynth(PyoObject):
        """
        Phase Vocoder synthesis object.

        PVSynth takes a PyoPVObject as its input and performed
        the spectral to time domain conversion on it. This step
        converts phase vocoder magnitude and true frequency's
        streams back to a real signal.

        :Parent: :py:class:`PyoObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            wintype: int, optional
                Shape of the envelope used to filter each input frame.
                Possible shapes are:

                0. rectangular (no windowing)
                1. Hamming
                2. Hanning (default)
                3. Bartlett (triangular)
                4. Blackman 3-term
                5. Blackman-Harris 4-term
                6. Blackman-Harris 7-term
                7. Tuckey (alpha = 0.66)
                8. Sine (half-sine window)

        >>> s = Server().boot()
        >>> s.start()
        >>> a = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=0.7)
        >>> pva = PVAnal(a, size=1024, overlaps=4, wintype=2)
        >>> pvs = PVSynth(pva).mix(2).out()

        """

        def __init__(self, input, wintype=2, mul=1, add=0):
            pyoArgsAssert(self, "piOO", input, wintype, mul, add)
            PyoObject.__init__(self, mul, add)
            self._input = input
            self._wintype = wintype
            input, wintype, mul, add, lmax = convertArgsToLists(self._input, wintype, mul, add)
            self._base_objs = [
                PVSynth_base(wrap(input, i), wrap(wintype, i), wrap(mul, i), wrap(add, i)) for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setWinType(self, x):
            """
            Replace the `wintype` attribute.

            :Args:

                x: int
                    new `wintype` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._wintype = x
            x, lmax = convertArgsToLists(x)
            [obj.setWinType(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMapMul(self._mul)]
            PyoObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def wintype(self):
            """int. Windowing method."""
            return self._wintype

        @wintype.setter
        def wintype(self, x):
            self.setWinType(x)

    class PVAddSynth(PyoObject):
        """
        Phase Vocoder additive synthesis object.

        PVAddSynth takes a PyoPVObject as its input and resynthesize
        the real signal using the magnitude and true frequency's
        streams to control amplitude and frequency envelopes of an
        oscillator bank.

        :Parent: :py:class:`PyoObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            pitch: float or PyoObject, optional
                Transposition factor. Defaults to 1.
            num: int, optional
                Number of oscillators used to synthesize the
                output sound. Defaults to 100.
            first: int, optional
                The first bin to synthesize, starting from 0.
                Defaults to 0.
            inc: int, optional
                Starting from bin `first`, resynthesize bins
                `inc` apart. Defaults to 1.

        >>> s = Server().boot()
        >>> s.start()
        >>> a = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=0.7)
        >>> pva = PVAnal(a, size=1024, overlaps=4, wintype=2)
        >>> pvs = PVAddSynth(pva, pitch=1.25, num=100, first=0, inc=2).out()

        """

        def __init__(self, input, pitch=1, num=100, first=0, inc=1, mul=1, add=0):
            pyoArgsAssert(self, "pOiiiOO", input, pitch, num, first, inc, mul, add)
            PyoObject.__init__(self, mul, add)
            self._input = input
            self._pitch = pitch
            self._num = num
            self._first = first
            self._inc = inc
            input, pitch, num, first, inc, mul, add, lmax = convertArgsToLists(
                self._input, pitch, num, first, inc, mul, add
            )
            self._base_objs = [
                PVAddSynth_base(
                    wrap(input, i), wrap(pitch, i), wrap(num, i), wrap(first, i), wrap(inc, i), wrap(mul, i), wrap(add, i)
                )
                for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setPitch(self, x):
            """
            Replace the `pitch` attribute.

            :Args:

                x: float or PyoObject
                    new `pitch` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._pitch = x
            x, lmax = convertArgsToLists(x)
            [obj.setPitch(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setNum(self, x):
            """
            Replace the `num` attribute.

            :Args:

                x: int
                    new `num` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._num = x
            x, lmax = convertArgsToLists(x)
            [obj.setNum(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setFirst(self, x):
            """
            Replace the `first` attribute.

            :Args:

                x: int
                    new `first` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._first = x
            x, lmax = convertArgsToLists(x)
            [obj.setFirst(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setInc(self, x):
            """
            Replace the `inc` attribute.

            :Args:

                x: int
                    new `inc` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._inc = x
            x, lmax = convertArgsToLists(x)
            [obj.setInc(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(0.25, 4, "lin", "pitch", self._pitch), SLMapMul(self._mul)]
            PyoObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def pitch(self):
            """float or PyoObject. Transposition factor."""
            return self._pitch

        @pitch.setter
        def pitch(self, x):
            self.setPitch(x)

        @property
        def num(self):
            """int. Number of oscillators."""
            return self._num

        @num.setter
        def num(self, x):
            self.setNum(x)

        @property
        def first(self):
            """int. First bin to synthesize."""
            return self._first

        @first.setter
        def first(self, x):
            self.setFirst(x)

        @property
        def inc(self):
            """int. Synthesized bin increment."""
            return self._inc

        @inc.setter
        def inc(self, x):
            self.setInc(x)

    class PVTranspose(PyoPVObject):
        """
        Transpose the frequency components of a pv stream.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            transpo: float or PyoObject, optional
                Transposition factor. Defaults to 1.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.7)
        >>> pva = PVAnal(sf, size=1024)
        >>> pvt = PVTranspose(pva, transpo=1.5)
        >>> pvs = PVSynth(pvt).out()
        >>> dry = Delay(sf, delay=1024./s.getSamplingRate(), mul=.7).out(1)

        """

        def __init__(self, input, transpo=1):
            pyoArgsAssert(self, "pO", input, transpo)
            PyoPVObject.__init__(self)
            self._input = input
            self._transpo = transpo
            input, transpo, lmax = convertArgsToLists(self._input, transpo)
            self._base_objs = [PVTranspose_base(wrap(input, i), wrap(transpo, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setTranspo(self, x):
            """
            Replace the `transpo` attribute.

            :Args:

                x: int
                    new `transpo` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._transpo = x
            x, lmax = convertArgsToLists(x)
            [obj.setTranspo(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(0.25, 4, "lin", "transpo", self._transpo)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def transpo(self):
            """float or PyoObject. Transposition factor."""
            return self._transpo

        @transpo.setter
        def transpo(self, x):
            self.setTranspo(x)

    class PVVerb(PyoPVObject):
        """
        Spectral domain reverberation.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            revtime: float or PyoObject, optional
                Reverberation factor, between 0 and 1.
                Defaults to 0.75.
            damp: float or PyoObject, optional
                High frequency damping factor, between 0 and 1.
                1 means no damping and 0 is the most damping.
                Defaults to 0.75.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.5)
        >>> pva = PVAnal(sf, size=2048)
        >>> pvg = PVGate(pva, thresh=-36, damp=0)
        >>> pvv = PVVerb(pvg, revtime=0.95, damp=0.95)
        >>> pvs = PVSynth(pvv).mix(2).out()
        >>> dry = Delay(sf, delay=2048./s.getSamplingRate(), mul=.4).mix(2).out()

        """

        def __init__(self, input, revtime=0.75, damp=0.75):
            pyoArgsAssert(self, "pOO", input, revtime, damp)
            PyoPVObject.__init__(self)
            self._input = input
            self._revtime = revtime
            self._damp = damp
            input, revtime, damp, lmax = convertArgsToLists(self._input, revtime, damp)
            self._base_objs = [PVVerb_base(wrap(input, i), wrap(revtime, i), wrap(damp, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setRevtime(self, x):
            """
            Replace the `revtime` attribute.

            :Args:

                x: int
                    new `revtime` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._revtime = x
            x, lmax = convertArgsToLists(x)
            [obj.setRevtime(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setDamp(self, x):
            """
            Replace the `damp` attribute.

            :Args:

                x: int
                    new `damp` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._damp = x
            x, lmax = convertArgsToLists(x)
            [obj.setDamp(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(0, 1, "lin", "revtime", self._revtime), SLMap(0, 1, "lin", "damp", self._damp)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def revtime(self):
            """float or PyoObject. Reverberation factor."""
            return self._revtime

        @revtime.setter
        def revtime(self, x):
            self.setRevtime(x)

        @property
        def damp(self):
            """float or PyoObject. High frequency damping factor."""
            return self._damp

        @damp.setter
        def damp(self, x):
            self.setDamp(x)

    class PVGate(PyoPVObject):
        """
        Spectral gate.

        :Parent: :py:class:`PyoObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            thresh: float or PyoObject, optional
                Threshold factor in dB. Bins below that threshold
                will be scaled by `damp` factor. Defaults to -20.
            damp: float or PyoObject, optional
                Damping factor for low amplitude bins. Defaults to 0.
            inverse: boolean, optional
                If True, the damping factor will be applied to the bins
                with amplitude above the given threshold. If False, the
                damping factor is applied to bins with amplitude below
                the given threshold. Defaults to False.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.5)
        >>> pva = PVAnal(sf, size=2048)
        >>> pvg = PVGate(pva, thresh=-50, damp=0)
        >>> pvs = PVSynth(pvg).mix(2).out()

        """

        def __init__(self, input, thresh=-20, damp=0.0, inverse=False):
            pyoArgsAssert(self, "pOOb", input, thresh, damp, inverse)
            PyoPVObject.__init__(self)
            self._input = input
            self._thresh = thresh
            self._damp = damp
            self._inverse = inverse
            input, thresh, damp, inverse, lmax = convertArgsToLists(self._input, thresh, damp, inverse)
            self._base_objs = [
                PVGate_base(wrap(input, i), wrap(thresh, i), wrap(damp, i), wrap(inverse, i)) for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setThresh(self, x):
            """
            Replace the `thresh` attribute.

            :Args:

                x: int
                    new `thresh` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._thresh = x
            x, lmax = convertArgsToLists(x)
            [obj.setThresh(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setDamp(self, x):
            """
            Replace the `damp` attribute.

            :Args:

                x: int
                    new `damp` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._damp = x
            x, lmax = convertArgsToLists(x)
            [obj.setDamp(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setInverse(self, x):
            """
            Replace the `inverse` attribute.

            :Args:

                x: boolean
                    new `inverse` attribute.

            """
            pyoArgsAssert(self, "b", x)
            self._inverse = x
            x, lmax = convertArgsToLists(x)
            [obj.setInverse(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(-120, 18, "lin", "thresh", self._thresh), SLMap(0, 2, "lin", "damp", self._damp)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def thresh(self):
            """float or PyoObject. Threshold factor."""
            return self._thresh

        @thresh.setter
        def thresh(self, x):
            self.setThresh(x)

        @property
        def damp(self):
            """float or PyoObject. Damping factor for low amplitude bins."""
            return self._damp

        @damp.setter
        def damp(self, x):
            self.setDamp(x)

        @property
        def inverse(self):
            """boolean. If True, the gate is applied to high amplitude bins."""
            return self._inverse

        @inverse.setter
        def inverse(self, x):
            self.setInverse(x)

    class PVCross(PyoPVObject):
        """
        Performs cross-synthesis between two phase vocoder streaming object.

        The amplitudes from `input` and `input2` (scaled by `fade` argument)
        are applied to the frequencies of `input`.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process. Frequencies from
                this pv stream are used to compute the output signal.
            input2: PyoPVObject
                Phase vocoder streaming object which gives the second set of
                magnitudes. Frequencies from this pv stream are not used.
            fade: float or PyoObject, optional
                Scaling factor for the output amplitudes, between 0 and 1.
                0 means amplitudes from `input` and 1 means amplitudes from `input2`.
                Defaults to 1.

        .. note::

            The two input pv stream must have the same size and overlaps. It is
            the responsibility of the user to be sure they are consistent. To change
            the size (or the overlaps) of the phase vocoder process, one must
            write a function to change both at the same time (see the example below).
            Another possibility is to use channel expansion to analyse both sounds
            with the same PVAnal object.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = SineLoop(freq=[80,81], feedback=0.07, mul=.5)
        >>> sf2 = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.5)
        >>> pva = PVAnal(sf)
        >>> pva2 = PVAnal(sf2)
        >>> pvc = PVCross(pva, pva2, fade=1)
        >>> pvs = PVSynth(pvc).out()
        >>> def size(x):
        ...     pva.size = x
        ...     pva2.size = x
        >>> def olaps(x):
        ...     pva.overlaps = x
        ...     pva2.overlaps = x

        """

        def __init__(self, input, input2, fade=1):
            pyoArgsAssert(self, "ppO", input, input2, fade)
            PyoPVObject.__init__(self)
            self._input = input
            self._input2 = input2
            self._fade = fade
            input, input2, fade, lmax = convertArgsToLists(self._input, self._input2, fade)
            self._base_objs = [PVCross_base(wrap(input, i), wrap(input2, i), wrap(fade, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setInput2(self, x):
            """
            Replace the `input2` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input2 = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput2(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setFade(self, x):
            """
            Replace the `fade` attribute.

            :Args:

                x: float or PyoObject
                    new `fade` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._fade = x
            x, lmax = convertArgsToLists(x)
            [obj.setFade(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(0, 1, "lin", "fade", self._fade)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def input2(self):
            """PyoPVObject. Second set of amplitudes."""
            return self._input2

        @input2.setter
        def input2(self, x):
            self.setInput2(x)

        @property
        def fade(self):
            """float or PyoObject. Scaling factor."""
            return self._fade

        @fade.setter
        def fade(self, x):
            self.setFade(x)

    class PVMult(PyoPVObject):
        """
        Multiply magnitudes from two phase vocoder streaming object.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process. Frequencies from
                this pv stream are used to compute the output signal.
            input2: PyoPVObject
                Phase vocoder streaming object which gives the second set of
                magnitudes. Frequencies from this pv stream are not used.

        .. note::

            The two input pv stream must have the same size and overlaps. It is
            the responsibility of the user to be sure they are consistent. To change
            the size (or the overlaps) of the phase vocoder process, one must
            write a function to change both at the same time (see the example below).
            Another possibility is to use channel expansion to analyse both sounds
            with the same PVAnal object.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = FM(carrier=[100,150], ratio=[.999,.5005], index=20, mul=.4)
        >>> sf2 = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.5)
        >>> pva = PVAnal(sf)
        >>> pva2 = PVAnal(sf2)
        >>> pvc = PVMult(pva, pva2)
        >>> pvs = PVSynth(pvc).out()
        >>> def size(x):
        ...     pva.size = x
        ...     pva2.size = x
        >>> def olaps(x):
        ...     pva.overlaps = x
        ...     pva2.overlaps = x

        """

        def __init__(self, input, input2):
            pyoArgsAssert(self, "pp", input, input2)
            PyoPVObject.__init__(self)
            self._input = input
            self._input2 = input2
            input, input2, lmax = convertArgsToLists(self._input, self._input2)
            self._base_objs = [PVMult_base(wrap(input, i), wrap(input2, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setInput2(self, x):
            """
            Replace the `input2` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input2 = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput2(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def input2(self):
            """PyoPVObject. Second set of magnitudes."""
            return self._input2

        @input2.setter
        def input2(self, x):
            self.setInput2(x)

    class PVMorph(PyoPVObject):
        """
        Performs spectral morphing between two phase vocoder streaming object.

        According to `fade` argument, the amplitudes from `input` and `input2`
        are interpolated linearly while the frequencies are interpolated
        exponentially.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object which gives the first set of
                magnitudes and frequencies.
            input2: PyoPVObject
                Phase vocoder streaming object which gives the second set of
                magnitudes and frequencies.
            fade: float or PyoObject, optional
                Scaling factor for the output amplitudes and frequencies,
                between 0 and 1. 0 is `input` and 1 in `input2`. Defaults to 0.5.

        .. note::

            The two input pv stream must have the same size and overlaps. It is
            the responsibility of the user to be sure they are consistent. To change
            the size (or the overlaps) of the phase vocoder process, one must
            write a function to change both at the same time (see the example below).
            Another possibility is to use channel expansion to analyse both sounds
            with the same PVAnal object.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = SineLoop(freq=[100,101], feedback=0.12, mul=.5)
        >>> sf2 = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.5)
        >>> pva = PVAnal(sf)
        >>> pva2 = PVAnal(sf2)
        >>> pvc = PVMorph(pva, pva2, fade=0.5)
        >>> pvs = PVSynth(pvc).out()
        >>> def size(x):
        ...     pva.size = x
        ...     pva2.size = x
        >>> def olaps(x):
        ...     pva.overlaps = x
        ...     pva2.overlaps = x

        """

        def __init__(self, input, input2, fade=0.5):
            pyoArgsAssert(self, "ppO", input, input2, fade)
            PyoPVObject.__init__(self)
            self._input = input
            self._input2 = input2
            self._fade = fade
            input, input2, fade, lmax = convertArgsToLists(self._input, self._input2, fade)
            self._base_objs = [PVMorph_base(wrap(input, i), wrap(input2, i), wrap(fade, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setInput2(self, x):
            """
            Replace the `input2` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input2 = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput2(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setFade(self, x):
            """
            Replace the `fade` attribute.

            :Args:

                x: float or PyoObject
                    new `fade` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._fade = x
            x, lmax = convertArgsToLists(x)
            [obj.setFade(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(0, 1, "lin", "fade", self._fade)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. First input signal."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def input2(self):
            """PyoPVObject. Second input signal."""
            return self._input2

        @input2.setter
        def input2(self, x):
            self.setInput2(x)

        @property
        def fade(self):
            """float or PyoObject. Scaling factor."""
            return self._fade

        @fade.setter
        def fade(self, x):
            self.setFade(x)

    class PVFilter(PyoPVObject):
        """
        Spectral filter.

        PVFilter filters frequency components of a pv stream
        according to the shape drawn in the table given in
        argument.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            table: PyoTableObject
                Table containing the filter shape. If the
                table length is smaller than fftsize/2,
                remaining bins will be set to 0.
            gain: float or PyoObject, optional
                Gain of the filter applied to the input spectrum.
                Defaults to 1.
            mode: int, optional
                Table scanning mode. Defaults to 0.

                If 0, bin indexes outside table size are set to 0.
                If 1, bin indexes are scaled over table length.

        >>> s = Server().boot()
        >>> s.start()
        >>> t = ExpTable([(0,1),(61,1),(71,0),(131,1),(171,0),(511,0)], size=512)
        >>> src = Noise(.4)
        >>> pva = PVAnal(src, size=1024)
        >>> pvf = PVFilter(pva, t)
        >>> pvs = PVSynth(pvf).out()

        """

        def __init__(self, input, table, gain=1, mode=0):
            pyoArgsAssert(self, "ptOi", input, table, gain, mode)
            PyoPVObject.__init__(self)
            self._input = input
            self._table = table
            self._gain = gain
            self._mode = mode
            input, table, gain, mode, lmax = convertArgsToLists(self._input, table, gain, mode)
            self._base_objs = [
                PVFilter_base(wrap(input, i), wrap(table, i), wrap(gain, i), wrap(mode, i)) for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setTable(self, x):
            """
            Replace the `table` attribute.

            :Args:

                x: PyoTableObject
                    new `table` attribute.

            """
            pyoArgsAssert(self, "t", x)
            self._table = x
            x, lmax = convertArgsToLists(x)
            [obj.setTable(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setGain(self, x):
            """
            Replace the `gain` attribute.

            :Args:

                x: float or PyoObject
                    new `gain` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._gain = x
            x, lmax = convertArgsToLists(x)
            [obj.setGain(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setMode(self, x):
            """
            Replace the `mode` attribute.

            :Args:

                x: int
                    new `mode` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._mode = x
            x, lmax = convertArgsToLists(x)
            [obj.setMode(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(0, 1, "lin", "gain", self._gain)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def table(self):
            """PyoTableObject. Table containing the filter shape."""
            return self._table

        @table.setter
        def table(self, x):
            self.setTable(x)

        @property
        def gain(self):
            """float or PyoObject. Gain of the filter."""
            return self._gain

        @gain.setter
        def gain(self, x):
            self.setGain(x)

        @property
        def mode(self):
            """int. Table scanning mode."""
            return self._mode

        @mode.setter
        def mode(self, x):
            self.setMode(x)

    class PVDelay(PyoPVObject):
        """
        Spectral delays.

        PVDelay applies different delay times and feedbacks for
        each bin of a phase vocoder analysis. Delay times and
        feedbacks are specified with PyoTableObjects.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            deltable: PyoTableObject
                Table containing delay times, as integer multipliers
                of the FFT hopsize (fftsize / overlaps).

                If the table length is smaller than fftsize/2,
                remaining bins will be set to 0.
            feedtable: PyoTableObject
                Table containing feedback values, between -1 and 1.

                If the table length is smaller than fftsize/2,
                remaining bins will be set to 0.
            maxdelay: float, optional
                Maximum delay time in seconds. Available at initialization
                time only. Defaults to 1.0.
            mode: int, optional
                Tables scanning mode. Defaults to 0.

                If 0, bin indexes outside table size are set to 0.
                If 1, bin indexes are scaled over table length.

        >>> s = Server().boot()
        >>> s.start()
        >>> SIZE = 1024
        >>> SIZE2 = int(SIZE / 2)
        >>> OLAPS = 4
        >>> MAXDEL = 2.0 # two seconds delay memories
        >>> FRAMES = int(MAXDEL * s.getSamplingRate() / (SIZE / OLAPS))
        >>> # Edit tables with the graph() method. yrange=(0, FRAMES) for delays table
        >>> dt = DataTable(size=SIZE2, init=[i / float(SIZE2) * FRAMES for i in range(SIZE2)])
        >>> ft = DataTable(size=SIZE2, init=[0.5]*SIZE2)
        >>> src = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=0.5)
        >>> pva = PVAnal(src, size=SIZE, overlaps=OLAPS)
        >>> pvd = PVDelay(pva, dt, ft, maxdelay=MAXDEL)
        >>> pvs = PVSynth(pvd).out()

        """

        def __init__(self, input, deltable, feedtable, maxdelay=1.0, mode=0):
            pyoArgsAssert(self, "pttni", input, deltable, feedtable, maxdelay, mode)
            PyoPVObject.__init__(self)
            self._input = input
            self._deltable = deltable
            self._feedtable = feedtable
            self._maxdelay = maxdelay
            self._mode = mode
            input, deltable, feedtable, maxdelay, mode, lmax = convertArgsToLists(
                self._input, deltable, feedtable, maxdelay, mode
            )
            self._base_objs = [
                PVDelay_base(wrap(input, i), wrap(deltable, i), wrap(feedtable, i), wrap(maxdelay, i), wrap(mode, i))
                for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setDeltable(self, x):
            """
            Replace the `deltable` attribute.

            :Args:

                x: PyoTableObject
                    new `deltable` attribute.

            """
            pyoArgsAssert(self, "t", x)
            self._deltable = x
            x, lmax = convertArgsToLists(x)
            [obj.setDeltable(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setFeedtable(self, x):
            """
            Replace the `feedtable` attribute.

            :Args:

                x: PyoTableObject
                    new `feedtable` attribute.

            """
            pyoArgsAssert(self, "t", x)
            self._feedtable = x
            x, lmax = convertArgsToLists(x)
            [obj.setFeedtable(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setMode(self, x):
            """
            Replace the `mode` attribute.

            :Args:

                x: int
                    new `mode` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._mode = x
            x, lmax = convertArgsToLists(x)
            [obj.setMode(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def deltable(self):
            """PyoTableObject. Table containing the delay times."""
            return self._deltable

        @deltable.setter
        def deltable(self, x):
            self.setDeltable(x)

        @property
        def feedtable(self):
            """PyoTableObject. Table containing feedback values."""
            return self._feedtable

        @feedtable.setter
        def feedtable(self, x):
            self.setFeedtable(x)

        @property
        def mode(self):
            """int. Table scanning mode."""
            return self._mode

        @mode.setter
        def mode(self, x):
            self.setMode(x)

    class PVBuffer(PyoPVObject):
        """
        Phase vocoder buffer and playback with transposition.

        PVBuffer keeps `length` seconds of pv analysis in memory
        and gives control on playback position and transposition.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            index: PyoObject
                Playback position, as audio stream, normalized
                between 0 and 1.
            pitch: float or PyoObject, optional
                Transposition factor. Defaults to 1.
            length: float, optional
                Memory length in seconds. Defaults to 1.0.

        .. note::

            The play() method can be called to start a new recording of
            the current pv input.

        >>> s = Server().boot()
        >>> s.start()
        >>> f = SNDS_PATH+'/transparent.aif'
        >>> f_len = sndinfo(f)[1]
        >>> src = SfPlayer(f, mul=0.5)
        >>> index = Phasor(freq=1.0/f_len*0.25, phase=0.9)
        >>> pva = PVAnal(src, size=1024, overlaps=8)
        >>> pvb = PVBuffer(pva, index, pitch=1.25, length=f_len)
        >>> pvs = PVSynth(pvb).out()

        """

        def __init__(self, input, index, pitch=1.0, length=1.0):
            pyoArgsAssert(self, "poOn", input, index, pitch, length)
            PyoPVObject.__init__(self)
            self._input = input
            self._index = index
            self._pitch = pitch
            self._length = length
            input, index, pitch, length, lmax = convertArgsToLists(self._input, index, pitch, length)
            self._base_objs = [
                PVBuffer_base(wrap(input, i), wrap(index, i), wrap(pitch, i), wrap(length, i)) for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setIndex(self, x):
            """
            Replace the `index` attribute.

            :Args:

                x: PyoObject
                    new `index` attribute.

            """
            pyoArgsAssert(self, "o", x)
            self._index = x
            x, lmax = convertArgsToLists(x)
            [obj.setIndex(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setPitch(self, x):
            """
            Replace the `pitch` attribute.

            :Args:

                x: float or PyoObject
                    new `pitch` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._pitch = x
            x, lmax = convertArgsToLists(x)
            [obj.setPitch(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setLength(self, x):
            """
            Replace the `length` attribute.

            :Args:

                x: float
                    new `length` attribute.

            """
            pyoArgsAssert(self, "n", x)
            self._length = x
            x, lmax = convertArgsToLists(x)
            [obj.setLength(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(0.25, 4, "lin", "pitch", self._pitch)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def index(self):
            """PyoObject. Reader's normalized position."""
            return self._index

        @index.setter
        def index(self, x):
            self.setIndex(x)

        @property
        def pitch(self):
            """float or PyoObject. Transposition factor."""
            return self._pitch

        @pitch.setter
        def pitch(self, x):
            self.setPitch(x)

        @property
        def length(self):
            """float. Buffer length in seconds."""
            return self._length

        @length.setter
        def length(self, x):
            self.setLength(x)

    class PVShift(PyoPVObject):
        """
        Spectral domain frequency shifter.

        PVShift linearly moves the analysis bins by the amount, in Hertz,
        specified by the the `shift` argument.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            shift: float or PyoObject, optional
                Frequency shift factor. Defaults to 0.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.7)
        >>> pva = PVAnal(sf, size=1024)
        >>> pvt = PVShift(pva, shift=500)
        >>> pvs = PVSynth(pvt).out()

        """

        def __init__(self, input, shift=0):
            pyoArgsAssert(self, "pO", input, shift)
            PyoPVObject.__init__(self)
            self._input = input
            self._shift = shift
            input, shift, lmax = convertArgsToLists(self._input, shift)
            self._base_objs = [PVShift_base(wrap(input, i), wrap(shift, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setShift(self, x):
            """
            Replace the `shift` attribute.

            :Args:

                x: float or PyoObject
                    new `shift` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._shift = x
            x, lmax = convertArgsToLists(x)
            [obj.setShift(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(-5000, 5000, "lin", "shift", self._shift)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def shift(self):
            """float or PyoObject. Frequency shift factor."""
            return self._shift

        @shift.setter
        def shift(self, x):
            self.setShift(x)

    class PVAmpMod(PyoPVObject):
        """
        Performs frequency independent amplitude modulations.

        PVAmpMod modulates the magnitude of each bin of a pv
        stream with an independent oscillator. `basefreq` and
        `spread` are used to derive the frequency of each
        modulating oscillator.

        Internally, the following operations are applied to
        derive oscillator frequencies (`i` is the bin number):

            spread = spread * 0.001 + 1.0

            f_i = basefreq * pow(spread, i)

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            basefreq: float or PyoObject, optional
                Base modulation frequency, in Hertz.
                Defaults to 1.
            spread: float or PyoObject, optional
                Spreading factor for oscillator frequencies, between
                -1 and 1. 0 means every oscillator has the same frequency.
            shape: int, optional
                Modulation oscillator waveform. Possible shapes are:
                    0. Sine (default)
                    1. Sawtooth
                    2. Ramp (inverse sawtooth)
                    3. Square
                    4. Triangle
                    5. Brown Noise
                    6. Pink Noise
                    7. White Noise

        >>> s = Server().boot()
        >>> s.start()
        >>> src = PinkNoise(.3)
        >>> pva = PVAnal(src, size=1024, overlaps=4)
        >>> pvm = PVAmpMod(pva, basefreq=4, spread=0.5)
        >>> pvs = PVSynth(pvm).out()

        """

        def __init__(self, input, basefreq=1, spread=0, shape=0):
            pyoArgsAssert(self, "pOOi", input, basefreq, spread, shape)
            PyoPVObject.__init__(self)
            self._input = input
            self._basefreq = basefreq
            self._spread = spread
            self._shape = shape
            input, basefreq, spread, shape, lmax = convertArgsToLists(self._input, basefreq, spread, shape)
            self._base_objs = [
                PVAmpMod_base(wrap(input, i), wrap(basefreq, i), wrap(spread, i), wrap(shape, i)) for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setBasefreq(self, x):
            """
            Replace the `basefreq` attribute.

            :Args:

                x: float or PyoObject
                    new `basefreq` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._basefreq = x
            x, lmax = convertArgsToLists(x)
            [obj.setBasefreq(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setSpread(self, x):
            """
            Replace the `spread` attribute.

            :Args:

                x: float or PyoObject
                    new `spread` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._spread = x
            x, lmax = convertArgsToLists(x)
            [obj.setSpread(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setShape(self, x):
            """
            Replace the `shape` attribute.

            :Args:

                x: int
                    new `shape` attribute. Possible shapes are:
                        0. Sine (default)
                        1. Sawtooth
                        2. Ramp (inverse sawtooth)
                        3. Square
                        4. Triangle
                        5. Brown Noise
                        6. Pink Noise
                        7. White Noise

            """
            pyoArgsAssert(self, "i", x)
            self._shape = x
            x, lmax = convertArgsToLists(x)
            [obj.setShape(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def reset(self):
            """
            Resets modulation pointers to 0.

            """
            [obj.reset() for obj in self._base_objs]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [
                SLMap(0.1, 20, "log", "basefreq", self._basefreq),
                SLMap(-1, 1, "lin", "spread", self._spread),
            ]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def basefreq(self):
            """float or PyoObject. Modulator's base frequency."""
            return self._basefreq

        @basefreq.setter
        def basefreq(self, x):
            self.setBasefreq(x)

        @property
        def spread(self):
            """float or PyoObject. Modulator's frequency spreading factor."""
            return self._spread

        @spread.setter
        def spread(self, x):
            self.setSpread(x)

        @property
        def shape(self):
            """int. Modulation oscillator waveform."""
            return self._shape

        @shape.setter
        def shape(self, x):
            self.setShape(x)

    class PVFreqMod(PyoPVObject):
        """
        Performs frequency independent frequency modulations.

        PVFreqMod modulates the frequency of each bin of a pv
        stream with an independent oscillator. `basefreq` and
        `spread` are used to derive the frequency of each
        modulating oscillator.

        Internally, the following operations are applied to
        derive oscillator frequencies (`i` is the bin number):

            spread = spread * 0.001 + 1.0

            f_i = basefreq * pow(spread, i)

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            basefreq: float or PyoObject, optional
                Base modulation frequency, in Hertz.
                Defaults to 1.
            spread: float or PyoObject, optional
                Spreading factor for oscillator frequencies, between
                -1 and 1. 0 means every oscillator has the same frequency.
            depth: float or PyoObject, optional
                Amplitude of the modulating oscillators, between 0 and 1.
                Defaults to 0.1.
            shape: int, optional
                Modulation oscillator waveform. Possible shapes are:
                    0. Sine (default)
                    1. Sawtooth
                    2. Ramp (inverse sawtooth)
                    3. Square
                    4. Triangle
                    5. Brown Noise
                    6. Pink Noise
                    7. White Noise

        >>> s = Server().boot()
        >>> s.start()
        >>> src = SfPlayer(SNDS_PATH+"/accord.aif", loop=True, mul=0.5)
        >>> pva = PVAnal(src, size=1024, overlaps=4)
        >>> pvm = PVFreqMod(pva, basefreq=8, spread=0.75, depth=0.05)
        >>> pvs = PVSynth(pvm).out()

        """

        def __init__(self, input, basefreq=1, spread=0, depth=0.1, shape=0):
            pyoArgsAssert(self, "pOOOi", input, basefreq, spread, depth, shape)
            PyoPVObject.__init__(self)
            self._input = input
            self._basefreq = basefreq
            self._spread = spread
            self._depth = depth
            self._shape = shape
            input, basefreq, spread, depth, shape, lmax = convertArgsToLists(self._input, basefreq, spread, depth, shape)
            self._base_objs = [
                PVFreqMod_base(wrap(input, i), wrap(basefreq, i), wrap(spread, i), wrap(depth, i), wrap(shape, i))
                for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setBasefreq(self, x):
            """
            Replace the `basefreq` attribute.

            :Args:

                x: float or PyoObject
                    new `basefreq` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._basefreq = x
            x, lmax = convertArgsToLists(x)
            [obj.setBasefreq(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setSpread(self, x):
            """
            Replace the `spread` attribute.

            :Args:

                x: float or PyoObject
                    new `spread` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._spread = x
            x, lmax = convertArgsToLists(x)
            [obj.setSpread(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setDepth(self, x):
            """
            Replace the `depth` attribute.

            :Args:

                x: float or PyoObject
                    new `depth` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._depth = x
            x, lmax = convertArgsToLists(x)
            [obj.setDepth(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setShape(self, x):
            """
            Replace the `shape` attribute.

            :Args:

                x: int
                    new `shape` attribute. Possible shapes are:
                        0. Sine (default)
                        1. Sawtooth
                        2. Ramp (inverse sawtooth)
                        3. Square
                        4. Triangle
                        5. Brown Noise
                        6. Pink Noise
                        7. White Noise

            """
            pyoArgsAssert(self, "i", x)
            self._shape = x
            x, lmax = convertArgsToLists(x)
            [obj.setShape(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def reset(self):
            """
            Resets modulation pointers to 0.

            """
            [obj.reset() for obj in self._base_objs]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [
                SLMap(0.1, 20, "log", "basefreq", self._basefreq),
                SLMap(-1, 1, "lin", "spread", self._spread),
                SLMap(0, 1, "lin", "depth", self._depth),
            ]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def basefreq(self):
            """float or PyoObject. Modulator's base frequency."""
            return self._basefreq

        @basefreq.setter
        def basefreq(self, x):
            self.setBasefreq(x)

        @property
        def spread(self):
            """float or PyoObject. Modulator's frequencies spreading factor."""
            return self._spread

        @spread.setter
        def spread(self, x):
            self.setSpread(x)

        @property
        def depth(self):
            """float or PyoObject. Amplitude of the modulators."""
            return self._depth

        @depth.setter
        def depth(self, x):
            self.setDepth(x)

        @property
        def shape(self):
            """int. Modulation oscillator waveform."""
            return self._shape

        @shape.setter
        def shape(self, x):
            self.setShape(x)

    class PVBufLoops(PyoPVObject):
        """
        Phase vocoder buffer with bin independent speed playback.

        PVBufLoops keeps `length` seconds of pv analysis in memory
        and gives control on playback position independently for
        every frequency bin.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            low: float or PyoObject, optional
                Lowest bin speed factor. Defaults to 1.0.
            high: float or PyoObject, optional
                Highest bin speed factor. Defaults to 1.0.
            mode: int, optional
                Speed distribution algorithm. Available algorithms are:
                    0. linear, line between `low` and `high` (default)
                    1. exponential, exponential line between `low` and `high`
                    2. logarithmic, logarithmic line between `low` and `high`
                    3. random, uniform random between `low` and `high`
                    4. rand expon min, exponential random from `low` to `high`
                    5. rand expon max, exponential random from `high` to `low`
                    6. rand bi-expon, bipolar exponential random between `low` and `high`

            length: float, optional
                Memory length in seconds. Available at initialization
                time only. Defaults to 1.0.

        .. note::

            The play() method can be called to start a new recording of
            the current pv input.

        >>> s = Server().boot()
        >>> s.start()
        >>> f = SNDS_PATH+'/transparent.aif'
        >>> f_len = sndinfo(f)[1]
        >>> src = SfPlayer(f, mul=0.5)
        >>> pva = PVAnal(src, size=1024, overlaps=8)
        >>> pvb = PVBufLoops(pva, low=0.9, high=1.1, mode=3, length=f_len)
        >>> pvs = PVSynth(pvb).out()

        """

        def __init__(self, input, low=1.0, high=1.0, mode=0, length=1.0):
            pyoArgsAssert(self, "pOOin", input, low, high, mode, length)
            PyoPVObject.__init__(self)
            self._input = input
            self._low = low
            self._high = high
            self._mode = mode
            self._length = length
            input, low, high, mode, length, lmax = convertArgsToLists(self._input, low, high, mode, length)
            self._base_objs = [
                PVBufLoops_base(wrap(input, i), wrap(low, i), wrap(high, i), wrap(mode, i), wrap(length, i))
                for i in range(lmax)
            ]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setLow(self, x):
            """
            Replace the `low` attribute.

            :Args:

                x: float or PyoObject
                    new `low` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._low = x
            x, lmax = convertArgsToLists(x)
            [obj.setLow(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setHigh(self, x):
            """
            Replace the `high` attribute.

            :Args:

                x: float or PyoObject
                    new `high` attribute.

            """
            pyoArgsAssert(self, "O", x)
            self._high = x
            x, lmax = convertArgsToLists(x)
            [obj.setHigh(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setMode(self, x):
            """
            Replace the `mode` attribute.

            :Args:

                x: int
                    new `mode` attribute.

            """
            pyoArgsAssert(self, "i", x)
            self._mode = x
            x, lmax = convertArgsToLists(x)
            [obj.setMode(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def reset(self):
            """
            Reset pointer positions to 0.

            """
            [obj.reset() for obj in self._base_objs]

        def ctrl(self, map_list=None, title=None, wxnoserver=False):
            self._map_list = [SLMap(-4, 4, "lin", "low", self._low), SLMap(-4, 4, "lin", "high", self._high)]
            PyoPVObject.ctrl(self, map_list, title, wxnoserver)

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def low(self):
            """float or PyoObject. Lowest bin speed factor."""
            return self._low

        @low.setter
        def low(self, x):
            self.setLow(x)

        @property
        def high(self):
            """float or PyoObject. Highest bin speed factor."""
            return self._high

        @high.setter
        def high(self, x):
            self.setHigh(x)

        @property
        def mode(self):
            """int. Speed distribution algorithm."""
            return self._mode

        @mode.setter
        def mode(self, x):
            self.setMode(x)

    class PVBufTabLoops(PyoPVObject):
        """
        Phase vocoder buffer with bin independent speed playback.

        PVBufTabLoops keeps `length` seconds of pv analysis in memory
        and gives control on playback position, using a PyoTableObject,
        independently for every frequency bin.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object to process.
            speed: PyoTableObject
                Table which specify the speed of bin playback readers.
            length: float, optional
                Memory length in seconds. Available at initialization
                time only. Defaults to 1.0.

        .. note::

            The play() method can be called to start a new recording of
            the current pv input.

        >>> s = Server().boot()
        >>> s.start()
        >>> f = SNDS_PATH+'/transparent.aif'
        >>> f_len = sndinfo(f)[1]
        >>> src = SfPlayer(f, mul=0.5)
        >>> spd = ExpTable([(0,1), (512,0.5)], exp=6, size=512)
        >>> pva = PVAnal(src, size=1024, overlaps=8)
        >>> pvb = PVBufTabLoops(pva, spd, length=f_len)
        >>> pvs = PVSynth(pvb).out()

        """

        def __init__(self, input, speed, length=1.0):
            pyoArgsAssert(self, "ptn", input, speed, length)
            PyoPVObject.__init__(self)
            self._input = input
            self._speed = speed
            self._length = length
            input, speed, length, lmax = convertArgsToLists(self._input, speed, length)
            self._base_objs = [PVBufTabLoops_base(wrap(input, i), wrap(speed, i), wrap(length, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setSpeed(self, x):
            """
            Replace the `speed` attribute.

            :Args:

                x: PyoTableObject
                    new `speed` attribute.

            """
            pyoArgsAssert(self, "t", x)
            self._speed = x
            x, lmax = convertArgsToLists(x)
            [obj.setSpeed(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def reset(self):
            """
            Reset pointer positions to 0.

            """
            [obj.reset() for obj in self._base_objs]

        @property
        def input(self):
            """PyoPVObject. Input signal to process."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def speed(self):
            """PyoTableObject. Table which specify the speed of bin playback readers."""
            return self._speed

        @speed.setter
        def speed(self, x):
            self.setSpeed(x)

    class PVMix(PyoPVObject):
        """
        Mix the most prominent components from two phase vocoder streaming objects.

        :Parent: :py:class:`PyoPVObject`

        :Args:

            input: PyoPVObject
                Phase vocoder streaming object 1.
            input2: PyoPVObject
                Phase vocoder streaming object 2.

        .. note::

            The two input pv stream must have the same size and overlaps. It is
            the responsibility of the user to be sure they are consistent. To change
            the size (or the overlaps) of the phase vocoder process, one must
            write a function to change both at the same time (see the example below).
            Another possibility is to use channel expansion to analyse both sounds
            with the same PVAnal object.

        >>> s = Server().boot()
        >>> s.start()
        >>> sf = SfPlayer(SNDS_PATH+"/transparent.aif", loop=True, mul=.5)
        >>> sf2 = SfPlayer(SNDS_PATH+"/accord.aif", loop=True, mul=.5)
        >>> pva = PVAnal(sf)
        >>> pva2 = PVAnal(sf2)
        >>> pvm = PVMix(pva, pva2)
        >>> pvs = PVSynth(pvm).out()
        >>> def size(x):
        ...     pva.size = x
        ...     pva2.size = x
        >>> def olaps(x):
        ...     pva.overlaps = x
        ...     pva2.overlaps = x

        """

        def __init__(self, input, input2):
            pyoArgsAssert(self, "pp", input, input2)
            PyoPVObject.__init__(self)
            self._input = input
            self._input2 = input2
            input, input2, lmax = convertArgsToLists(self._input, self._input2)
            self._base_objs = [PVMix_base(wrap(input, i), wrap(input2, i)) for i in range(lmax)]
            self._init_play()

        def setInput(self, x):
            """
            Replace the `input` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        def setInput2(self, x):
            """
            Replace the `input2` attribute.

            :Args:

                x: PyoPVObject
                    New signal to process.

            """
            pyoArgsAssert(self, "p", x)
            self._input2 = x
            x, lmax = convertArgsToLists(x)
            [obj.setInput2(wrap(x, i)) for i, obj in enumerate(self._base_objs)]

        @property
        def input(self):
            """PyoPVObject. Phase vocoder streaming object 1."""
            return self._input

        @input.setter
        def input(self, x):
            self.setInput(x)

        @property
        def input2(self):
            """PyoPVObject. Phase vocoder streaming object 2."""
            return self._input2

        @input2.setter
        def input2(self, x):
            self.setInput2(x)