Changes in / [8986239:152bf4f]


Ignore:
Location:
python/ext
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • python/ext/aubiomodule.c

    r8986239 r152bf4f  
    1111
    1212static char Py_alpha_norm_doc[] = ""
    13 "alpha_norm(vec, alpha)\n"
    14 "\n"
    15 "Compute `alpha` normalisation factor of vector `vec`.\n"
    16 "\n"
    17 "Parameters\n"
    18 "----------\n"
    19 "vec : fvec\n"
    20 "   input vector\n"
    21 "alpha : float\n"
    22 "   norm factor\n"
    23 "\n"
    24 "Returns\n"
    25 "-------\n"
    26 "float\n"
    27 "   p-norm of the input vector, where `p=alpha`\n"
    28 "\n"
    29 "Example\n"
    30 "-------\n"
    31 "\n"
    32 ">>> a = aubio.fvec(np.arange(10)); alpha = 2\n"
    33 ">>> aubio.alpha_norm(a, alpha), (sum(a**alpha)/len(a))**(1./alpha)\n"
    34 "(5.338539123535156, 5.338539126015656)\n"
    35 "\n"
    36 "Note\n"
    37 "----\n"
    38 "Computed as:\n"
    39 "\n"
    40 ".. math::\n"
    41 "  l_{\\alpha} = \n"
    42 "       \\|\\frac{\\sum_{n=0}^{N-1}{{x_n}^{\\alpha}}}{N}\\|^{1/\\alpha}\n"
    43 "";
     13"alpha_norm(fvec, integer) -> float\n"
     14"\n"
     15"Compute alpha normalisation factor on vector, given alpha\n"
     16"\n"
     17"Example\n"
     18"-------\n"
     19"\n"
     20">>> b = alpha_norm(a, 9)";
    4421
    4522static char Py_bintomidi_doc[] = ""
    46 "bintomidi(fftbin, samplerate, fftsize)\n"
    47 "\n"
    48 "Convert FFT bin to frequency in midi note, given the sampling rate\n"
    49 "and the size of the FFT.\n"
    50 "\n"
    51 "Parameters\n"
    52 "----------\n"
    53 "fftbin : float\n"
    54 "   input frequency bin\n"
    55 "samplerate : float\n"
    56 "   sampling rate of the signal\n"
    57 "fftsize : float\n"
    58 "   size of the FFT\n"
    59 "\n"
    60 "Returns\n"
    61 "-------\n"
    62 "float\n"
    63 "   Frequency converted to midi note.\n"
    64 "\n"
    65 "Example\n"
    66 "-------\n"
    67 "\n"
    68 ">>> aubio.bintomidi(10, 44100, 1024)\n"
    69 "68.62871551513672\n"
    70 "";
     23"bintomidi(float, samplerate = integer, fftsize = integer) -> float\n"
     24"\n"
     25"Convert bin (float) to midi (float), given the sampling rate and the FFT size\n"
     26"\n"
     27"Example\n"
     28"-------\n"
     29"\n"
     30">>> midi = bintomidi(float, samplerate = 44100, fftsize = 1024)";
    7131
    7232static char Py_miditobin_doc[] = ""
    73 "miditobin(midi, samplerate, fftsize)\n"
    74 "\n"
    75 "Convert frequency in midi note to FFT bin, given the sampling rate\n"
    76 "and the size of the FFT.\n"
    77 "\n"
    78 "Parameters\n"
    79 "----------\n"
    80 "midi : float\n"
    81 "   input frequency, in midi note\n"
    82 "samplerate : float\n"
    83 "   sampling rate of the signal\n"
    84 "fftsize : float\n"
    85 "   size of the FFT\n"
    86 "\n"
    87 "Returns\n"
    88 "-------\n"
    89 "float\n"
    90 "   Frequency converted to FFT bin.\n"
    91 "\n"
    92 "Examples\n"
    93 "--------\n"
    94 "\n"
    95 ">>> aubio.miditobin(69, 44100, 1024)\n"
    96 "10.216779708862305\n"
    97 ">>> aubio.miditobin(75.08, 32000, 512)\n"
    98 "10.002175331115723\n"
    99 "";
     33"miditobin(float, samplerate = integer, fftsize = integer) -> float\n"
     34"\n"
     35"Convert midi (float) to bin (float), given the sampling rate and the FFT size\n"
     36"\n"
     37"Example\n"
     38"-------\n"
     39"\n"
     40">>> bin = miditobin(midi, samplerate = 44100, fftsize = 1024)";
    10041
    10142static char Py_bintofreq_doc[] = ""
    102 "bintofreq(fftbin, samplerate, fftsize)\n"
    103 "\n"
    104 "Convert FFT bin to frequency in Hz, given the sampling rate\n"
    105 "and the size of the FFT.\n"
    106 "\n"
    107 "Parameters\n"
    108 "----------\n"
    109 "fftbin : float\n"
    110 "   input frequency bin\n"
    111 "samplerate : float\n"
    112 "   sampling rate of the signal\n"
    113 "fftsize : float\n"
    114 "   size of the FFT\n"
    115 "\n"
    116 "Returns\n"
    117 "-------\n"
    118 "float\n"
    119 "   Frequency converted to Hz.\n"
    120 "\n"
    121 "Example\n"
    122 "-------\n"
    123 "\n"
    124 ">>> aubio.bintofreq(10, 44100, 1024)\n"
    125 "430.6640625\n"
    126 "";
     43"bintofreq(float, samplerate = integer, fftsize = integer) -> float\n"
     44"\n"
     45"Convert bin number (float) in frequency (Hz), given the sampling rate and the FFT size\n"
     46"\n"
     47"Example\n"
     48"-------\n"
     49"\n"
     50">>> freq = bintofreq(bin, samplerate = 44100, fftsize = 1024)";
    12751
    12852static char Py_freqtobin_doc[] = ""
    129 "freqtobin(freq, samplerate, fftsize)\n"
    130 "\n"
    131 "Convert frequency in Hz to FFT bin, given the sampling rate\n"
    132 "and the size of the FFT.\n"
    133 "\n"
    134 "Parameters\n"
    135 "----------\n"
    136 "midi : float\n"
    137 "   input frequency, in midi note\n"
    138 "samplerate : float\n"
    139 "   sampling rate of the signal\n"
    140 "fftsize : float\n"
    141 "   size of the FFT\n"
    142 "\n"
    143 "Returns\n"
    144 "-------\n"
    145 "float\n"
    146 "   Frequency converted to FFT bin.\n"
    147 "\n"
    148 "Examples\n"
    149 "--------\n"
    150 "\n"
    151 ">>> aubio.freqtobin(440, 44100, 1024)\n"
    152 "10.216779708862305\n"
    153 "";
     53"freqtobin(float, samplerate = integer, fftsize = integer) -> float\n"
     54"\n"
     55"Convert frequency (Hz) in bin number (float), given the sampling rate and the FFT size\n"
     56"\n"
     57"Example\n"
     58"-------\n"
     59"\n"
     60">>> bin = freqtobin(freq, samplerate = 44100, fftsize = 1024)";
    15461
    15562static char Py_zero_crossing_rate_doc[] = ""
    156 "zero_crossing_rate(vec)\n"
    157 "\n"
    158 "Compute zero-crossing rate of `vec`.\n"
    159 "\n"
    160 "Parameters\n"
    161 "----------\n"
    162 "vec : fvec\n"
    163 "   input vector\n"
    164 "\n"
    165 "Returns\n"
    166 "-------\n"
    167 "float\n"
    168 "   Zero-crossing rate.\n"
    169 "\n"
    170 "Example\n"
    171 "-------\n"
    172 "\n"
    173 ">>> a = np.linspace(-1., 1., 1000, dtype=aubio.float_type)\n"
    174 ">>> aubio.zero_crossing_rate(a), 1/1000\n"
    175 "(0.0010000000474974513, 0.001)\n"
    176 "";
     63"zero_crossing_rate(fvec) -> float\n"
     64"\n"
     65"Compute Zero crossing rate of a vector\n"
     66"\n"
     67"Example\n"
     68"-------\n"
     69"\n"
     70">>> z = zero_crossing_rate(a)";
    17771
    17872static char Py_min_removal_doc[] = ""
    179 "min_removal(vec)\n"
    180 "\n"
    181 "Remove the minimum value of a vector to each of its element.\n"
    182 "\n"
    183 "Modifies the input vector in-place and returns a reference to it.\n"
    184 "\n"
    185 "Parameters\n"
    186 "----------\n"
    187 "vec : fvec\n"
    188 "   input vector\n"
    189 "\n"
    190 "Returns\n"
    191 "-------\n"
    192 "fvec\n"
    193 "   modified input vector\n"
    194 "\n"
    195 "Example\n"
    196 "-------\n"
    197 "\n"
    198 ">>> aubio.min_removal(aubio.fvec(np.arange(1,4)))\n"
    199 "array([0., 1., 2.], dtype=" AUBIO_NPY_SMPL_STR ")\n"
    200 "";
     73"min_removal(fvec) -> float\n"
     74"\n"
     75"Remove the minimum value of a vector, in-place modification\n"
     76"\n"
     77"Example\n"
     78"-------\n"
     79"\n"
     80">>> min_removal(a)";
    20181
    20282extern void add_ufuncs ( PyObject *m );

  • python/ext/py-cvec.c

    r8986239 r152bf4f  
    2020} Py_cvec;
    2121
    22 static char Py_cvec_doc[] = ""
    23 "cvec(size)\n"
    24 "\n"
    25 "Data structure to hold spectral vectors.\n"
    26 "\n"
    27 "A vector holding spectral data in two vectors, :attr:`phas`\n"
    28 "and :attr:`norm`. Each vector is a :class:`numpy.ndarray`\n"
    29 "of shape `(length,)`, where `length = size // 2 + 1`.\n"
    30 "\n"
    31 "Parameters\n"
    32 "----------\n"
    33 "size: int\n"
    34 "   Size of spectrum to create.\n"
    35 "\n"
    36 "Examples\n"
    37 "--------\n"
    38 ">>> c = aubio.cvec(1024)\n"
    39 ">>> c\n"
    40 "aubio cvec of 513 elements\n"
    41 ">>> c.length\n"
    42 "513\n"
    43 ">>> c.norm.dtype, c.phas.dtype\n"
    44 "(dtype('float32'), dtype('float32'))\n"
    45 ">>> c.norm.shape, c.phas.shape\n"
    46 "((513,), (513,))\n"
    47 "\n"
    48 "See Also\n"
    49 "--------\n"
    50 "fft, pvoc\n"
    51 "";
     22static char Py_cvec_doc[] = "cvec object";
    5223
    5324
    … …  
    212183  // TODO remove READONLY flag and define getter/setter
    213184  {"length", T_INT, offsetof (Py_cvec, length), READONLY,
    214       "int: Length of `norm` and `phas` vectors."},
     185      "length attribute"},
    215186  {NULL}                        /* Sentinel */
    216187};
    … …  
    221192
    222193static PyGetSetDef Py_cvec_getseters[] = {
    223   {"norm", (getter)Py_cvec_get_norm, (setter)Py_cvec_set_norm,
    224       "numpy.ndarray: Vector of shape `(length,)` containing the magnitude.",
     194  {"norm", (getter)Py_cvec_get_norm, (setter)Py_cvec_set_norm, 
     195      "Numpy vector of shape (length,) containing the magnitude",
    225196      NULL},
    226   {"phas", (getter)Py_cvec_get_phas, (setter)Py_cvec_set_phas,
    227       "numpy.ndarray: Vector of shape `(length,)` containing the phase.",
     197  {"phas", (getter)Py_cvec_get_phas, (setter)Py_cvec_set_phas, 
     198      "Numpy vector of shape (length,) containing the phase",
    228199      NULL},
    229200  {NULL} /* sentinel */

  • python/ext/py-musicutils.h

    r8986239 r152bf4f  
    33
    44static char Py_aubio_window_doc[] = ""
    5 "window(window_type, size)\n"
     5"window(string, integer) -> fvec\n"
    66"\n"
    7 "Create a window of length `size`. `window_type` should be one\n"
    8 "of the following:\n"
     7"Create a window\n"
    98"\n"
    10 "- `default` (same as `hanningz`).\n"
    11 "- `ones`\n"
    12 "- `rectangle`\n"
    13 "- `hamming`\n"
    14 "- `hanning`\n"
    15 "- `hanningz` [1]_\n"
    16 "- `blackman`\n"
    17 "- `blackman_harris`\n"
    18 "- `gaussian`\n"
    19 "- `welch`\n"
    20 "- `parzen`\n"
     9"Example\n"
     10"-------\n"
    2111"\n"
    22 "Parameters\n"
    23 "----------\n"
    24 "window_type : str\n"
    25 "   Type of window.\n"
    26 "size : int\n"
    27 "   Length of window.\n"
    28 "\n"
    29 "Returns\n"
    30 "-------\n"
    31 "fvec\n"
    32 "   Array of shape `(length,)` containing the new window.\n"
    33 "\n"
    34 "See Also\n"
    35 "--------\n"
    36 "pvoc, fft\n"
    37 "\n"
    38 "Examples\n"
    39 "--------\n"
    40 "Compute a zero-phase Hann window on `1024` points:\n"
    41 "\n"
    42 ">>> aubio.window('hanningz', 1024)\n"
     12">>> window('hanningz', 1024)\n"
    4313"array([  0.00000000e+00,   9.41753387e-06,   3.76403332e-05, ...,\n"
    44 "         8.46982002e-05,   3.76403332e-05,   9.41753387e-06], dtype=float32)\n"
    45 "\n"
    46 "Plot different window types with `matplotlib <https://matplotlib.org/>`_:\n"
    47 "\n"
    48 ">>> import matplotlib.pyplot as plt\n"
    49 ">>> modes = ['default', 'ones', 'rectangle', 'hamming', 'hanning',\n"
    50 "...          'hanningz', 'blackman', 'blackman_harris', 'gaussian',\n"
    51 "...          'welch', 'parzen']; n = 2048\n"
    52 ">>> for m in modes: plt.plot(aubio.window(m, n), label=m)\n"
    53 "...\n"
    54 ">>> plt.legend(); plt.show()\n"
    55 "\n"
    56 "Note\n"
    57 "----\n"
    58 "The following examples contain the equivalent source code to compute\n"
    59 "each type of window with `NumPy <https://numpy.org>`_:\n"
    60 "\n"
    61 ">>> n = 1024; x = np.arange(n, dtype=aubio.float_type)\n"
    62 ">>> ones = np.ones(n).astype(aubio.float_type)\n"
    63 ">>> rectangle = 0.5 * ones\n"
    64 ">>> hanning = 0.5 - 0.5 * np.cos(2 * np.pi * x / n)\n"
    65 ">>> hanningz = 0.5 * (1 - np.cos(2 * np.pi * x / n))\n"
    66 ">>> hamming = 0.54 - 0.46 * np.cos(2.*np.pi * x / (n - 1))\n"
    67 ">>> blackman = 0.42 \\\n"
    68 "...          - 0.50 * np.cos(2 * np.pi * x / (n - 1)) \\\n"
    69 "...          + 0.08 * np.cos(4 * np.pi * x / (n - 1))\n"
    70 ">>> blackman_harris = 0.35875 \\\n"
    71 "...       - 0.48829 * np.cos(2 * np.pi * x / (n - 1)) \\\n"
    72 "...       + 0.14128 * np.cos(4 * np.pi * x / (n - 1)) \\\n"
    73 "...       + 0.01168 * np.cos(6 * np.pi * x / (n - 1))\n"
    74 ">>> gaussian = np.exp( - 0.5 * ((x - 0.5 * (n - 1)) \\\n"
    75 "...                            / (0.25 * (n - 1)) )**2 )\n"
    76 ">>> welch = 1 - ((2 * x - n) / (n + 1))**2\n"
    77 ">>> parzen = 1 - np.abs((2 * x - n) / (n + 1))\n"
    78 ">>> default = hanningz\n"
    79 "References\n"
    80 "----------\n"
    81 #if 0
    82 "`Window function <https://en.wikipedia.org/wiki/Window_function>`_ on\n"
    83 "Wikipedia.\n"
    84 "\n"
    85 #endif
    86 ".. [1] Amalia de Götzen, Nicolas Bernardini, and Daniel Arfib. Traditional\n"
    87 "   (?) implementations of a phase vocoder: the tricks of the trade.\n"
    88 "   In *Proceedings of the International Conference on Digital Audio\n"
    89 "   Effects* (DAFx-00), pages 37–44, University of Verona, Italy, 2000.\n"
    90 "   (`online version <"
    91 "https://www.cs.princeton.edu/courses/archive/spr09/cos325/Bernardini.pdf"
    92 ">`_).\n"
    93 "";
     14"         8.46982002e-05,   3.76403332e-05,   9.41753387e-06], dtype=float32)";
    9415
    9516PyObject * Py_aubio_window(PyObject *self, PyObject *args);
    9617
    9718static char Py_aubio_level_lin_doc[] = ""
    98 "level_lin(x)\n"
     19"level_lin(fvec) -> fvec\n"
    9920"\n"
    100 "Compute sound pressure level of `x`, on a linear scale.\n"
     21"Compute sound level on a linear scale.\n"
    10122"\n"
    102 "Parameters\n"
    103 "----------\n"
    104 "x : fvec\n"
    105 "   input vector\n"
    106 "\n"
    107 "Returns\n"
    108 "-------\n"
    109 "float\n"
    110 "   Linear level of `x`.\n"
     23"This gives the average of the square amplitudes.\n"
    11124"\n"
    11225"Example\n"
    11326"-------\n"
    11427"\n"
    115 ">>> aubio.level_lin(aubio.fvec(numpy.ones(1024)))\n"
    116 "1.0\n"
    117 "\n"
    118 "Note\n"
    119 "----\n"
    120 "Computed as the average of the squared amplitudes:\n"
    121 "\n"
    122 ".. math:: L = \\frac {\\sum_{n=0}^{N-1} {x_n}^2} {N}\n"
    123 "\n"
    124 "See Also\n"
    125 "--------\n"
    126 "db_spl, silence_detection, level_detection\n"
    127 "";
     28">>> level_Lin(numpy.ones(1024))\n"
     29"1.0";
    12830
    12931PyObject * Py_aubio_level_lin(PyObject *self, PyObject *args);
    13032
    13133static char Py_aubio_db_spl_doc[] = ""
    132 "db_spl(x)\n"
     34"Compute sound pressure level (SPL) in dB\n"
    13335"\n"
    134 "Compute Sound Pressure Level (SPL) of `x`, in dB.\n"
     36"This quantity is often wrongly called 'loudness'.\n"
    13537"\n"
    136 "Parameters\n"
    137 "----------\n"
    138 "x : fvec\n"
    139 "   input vector\n"
    140 "\n"
    141 "Returns\n"
    142 "-------\n"
    143 "float\n"
    144 "   Level of `x`, in dB SPL.\n"
     38"This gives ten times the log10 of the average of the square amplitudes.\n"
    14539"\n"
    14640"Example\n"
    14741"-------\n"
    14842"\n"
    149 ">>> aubio.db_spl(aubio.fvec(np.ones(1024)))\n"
    150 "1.0\n"
    151 ">>> aubio.db_spl(0.7*aubio.fvec(np.ones(32)))\n"
    152 "-3.098040819168091\n"
    153 "\n"
    154 "Note\n"
    155 "----\n"
    156 "Computed as `log10` of :py:func:`level_lin`:\n"
    157 "\n"
    158 ".. math::\n"
    159 "\n"
    160 "   {SPL}_{dB} = log10{\\frac {\\sum_{n=0}^{N-1}{x_n}^2} {N}}\n"
    161 "\n"
    162 "This quantity is often incorrectly called 'loudness'.\n"
    163 "\n"
    164 "See Also\n"
    165 "--------\n"
    166 "level_lin, silence_detection, level_detection\n"
    167 "";
     43">>> db_spl(numpy.ones(1024))\n"
     44"1.0";
    16845
    16946PyObject * Py_aubio_db_spl(PyObject *self, PyObject *args);
    17047
    17148static char Py_aubio_silence_detection_doc[] = ""
    172 "silence_detection(vec, level)\n"
     49"Check if buffer level in dB SPL is under a given threshold\n"
    17350"\n"
    174 "Check if level of `vec`, in dB SPL, is under a given threshold.\n"
     51"Return 0 if level is under the given threshold, 1 otherwise.\n"
    17552"\n"
    176 "Parameters\n"
    177 "----------\n"
    178 "vec : fvec\n"
    179 "   input vector\n"
    180 "level : float\n"
    181 "   level threshold, in dB SPL\n"
     53"Example\n"
     54"-------\n"
    18255"\n"
    183 "Returns\n"
    184 "-------\n"
    185 "int\n"
    186 "   `1` if level of `vec`, in dB SPL, is under `level`,\n"
    187 "   `0` otherwise.\n"
    188 "\n"
    189 "Examples\n"
    190 "--------\n"
    191 "\n"
    192 ">>> aubio.silence_detection(aubio.fvec(32), -100.)\n"
    193 "1\n"
    194 ">>> aubio.silence_detection(aubio.fvec(np.ones(32)), 0.)\n"
    195 "0\n"
    196 "\n"
    197 "See Also\n"
    198 "--------\n"
    199 "level_detection, db_spl, level_lin\n"
    200 "";
     56">>> import numpy\n"""
     57">>> silence_detection(numpy.ones(1024, dtype=\"float32\"), -80)\n"
     58"0";
    20159
    20260PyObject * Py_aubio_silence_detection(PyObject *self, PyObject *args);
    20361
    20462static char Py_aubio_level_detection_doc[] = ""
    205 "level_detection(vec, level)\n"
    206 "\n"
    207 "Check if `vec` is above threshold `level`, in dB SPL.\n"
    208 "\n"
    209 "Parameters\n"
    210 "----------\n"
    211 "vec : fvec\n"
    212 "   input vector\n"
    213 "level : float\n"
    214 "   level threshold, in dB SPL\n"
    215 "\n"
    216 "Returns\n"
    217 "-------\n"
    218 "float\n"
    219 "   `1.0` if level of `vec` in dB SPL is under `level`,\n"
    220 "   `db_spl(vec)` otherwise.\n"
     63"Get buffer level in dB SPL if over a given threshold, 1. otherwise.\n"
    22164"\n"
    22265"Example\n"
    22366"-------\n"
    22467"\n"
    225 ">>> aubio.level_detection(0.7*aubio.fvec(np.ones(1024)), -3.)\n"
    226 "1.0\n"
    227 ">>> aubio.level_detection(0.7*aubio.fvec(np.ones(1024)), -4.)\n"
    228 "-3.0980708599090576\n"
    229 "\n"
    230 "See Also\n"
    231 "--------\n"
    232 "silence_detection, db_spl, level_lin\n"
    233 "";
     68">>> import numpy\n"""
     69">>> level_detection(0.7*numpy.ones(1024, dtype=\"float32\"), -80)\n"
     70"0";
    23471
    23572PyObject * Py_aubio_level_detection(PyObject *self, PyObject *args);
    23673
    23774static char Py_aubio_shift_doc[] = ""
    238 "shift(vec)\n"
     75"Swap left and right partitions of a vector\n"
    23976"\n"
    240 "Swap left and right partitions of a vector, in-place.\n"
    241 "\n"
    242 "Parameters\n"
    243 "----------\n"
    244 "vec : fvec\n"
    245 "   input vector to shift\n"
    246 "\n"
    247 "Returns\n"
    248 "-------\n"
    249 "fvec\n"
    250 "   The swapped vector.\n"
    251 "\n"
    252 "Notes\n"
    253 "-----\n"
    254 "The input vector is also modified.\n"
     77"Returns the swapped vector. The input vector is also modified.\n"
    25578"\n"
    25679"For a vector of length N, the partition is split at index N - N//2.\n"
    … …  
    25982"-------\n"
    26083"\n"
    261 ">>> aubio.shift(aubio.fvec(np.arange(3)))\n"
    262 "array([2., 0., 1.], dtype=" AUBIO_NPY_SMPL_STR ")\n"
    263 "\n"
    264 "See Also\n"
    265 "--------\n"
    266 "ishift\n"
    267 "";
     84">>> import numpy\n"
     85">>> shift(numpy.arange(3, dtype=aubio.float_type))\n"
     86"array([2., 0., 1.], dtype=" AUBIO_NPY_SMPL_STR ")";
    26887PyObject * Py_aubio_shift(PyObject *self, PyObject *args);
    26988
    27089static char Py_aubio_ishift_doc[] = ""
    271 "ishift(vec)\n"
     90"Swap right and left partitions of a vector\n"
    27291"\n"
    273 "Swap right and left partitions of a vector, in-place.\n"
     92"Returns the swapped vector. The input vector is also modified.\n"
    27493"\n"
    275 "Parameters\n"
    276 "----------\n"
    277 "vec : fvec\n"
    278 "   input vector to shift\n"
    279 "\n"
    280 "Returns\n"
    281 "-------\n"
    282 "fvec\n"
    283 "   The swapped vector.\n"
    284 "\n"
    285 "Notes\n"
    286 "-----\n"
    287 "The input vector is also modified.\n"
    288 "\n"
    289 "Unlike with :py:func:`shift`, the partition is split at index N//2.\n"
     94"Unlike with shift(), the partition is split at index N//2.\n"
    29095"\n"
    29196"Example\n"
    29297"-------\n"
    29398"\n"
    294 ">>> aubio.ishift(aubio.fvec(np.arange(3)))\n"
    295 "array([1., 2., 0.], dtype=" AUBIO_NPY_SMPL_STR ")\n"
    296 "\n"
    297 "See Also\n"
    298 "--------\n"
    299 "shift\n"
    300 "";
     99">>> import numpy\n"
     100">>> ishift(numpy.arange(3, dtype=aubio.float_type))\n"
     101"array([1., 2., 0.], dtype=" AUBIO_NPY_SMPL_STR ")";
    301102PyObject * Py_aubio_ishift(PyObject *self, PyObject *args);
    302103

  • python/ext/py-phasevoc.c

    r8986239 r152bf4f  
    11#include "aubio-types.h"
    22
    3 static char Py_pvoc_doc[] = ""
    4 "pvoc(win_s=512, hop_s=256)\n"
    5 "\n"
    6 "Phase vocoder.\n"
    7 "\n"
    8 "`pvoc` creates callable object implements a phase vocoder [1]_,\n"
    9 "using the tricks detailed in [2]_.\n"
    10 "\n"
    11 "The call function takes one input of type `fvec` and of size\n"
    12 "`hop_s`, and returns a `cvec` of length `win_s//2+1`.\n"
    13 "\n"
    14 "Parameters\n"
    15 "----------\n"
    16 "win_s : int\n"
    17 "  number of channels in the phase-vocoder.\n"
    18 "hop_s : int\n"
    19 "  number of samples expected between each call\n"
    20 "\n"
    21 "Examples\n"
    22 "--------\n"
    23 ">>> x = aubio.fvec(256)\n"
    24 ">>> pv = aubio.pvoc(512, 256)\n"
    25 ">>> pv(x)\n"
    26 "aubio cvec of 257 elements\n"
    27 "\n"
    28 "Default values for hop_s and win_s are provided:\n"
    29 "\n"
    30 ">>> pv = aubio.pvoc()\n"
    31 ">>> pv.win_s, pv.hop_s\n"
    32 "512, 256\n"
    33 "\n"
    34 "A `cvec` can be resynthesised using `rdo()`:\n"
    35 "\n"
    36 ">>> pv = aubio.pvoc(512, 256)\n"
    37 ">>> y = aubio.cvec(512)\n"
    38 ">>> x_reconstructed = pv.rdo(y)\n"
    39 ">>> x_reconstructed.shape\n"
    40 "(256,)\n"
    41 "\n"
    42 "References\n"
    43 "----------\n"
    44 ".. [1] James A. Moorer. The use of the phase vocoder in computer music\n"
    45 "   applications. `Journal of the Audio Engineering Society`,\n"
    46 "   26(1/2):42–45, 1978.\n"
    47 ".. [2] Amalia de Götzen, Nicolas Bernardini, and Daniel Arfib. Traditional\n"
    48 "   (?) implementations of a phase vocoder: the tricks of the trade.\n"
    49 "   In `Proceedings of the International Conference on Digital Audio\n"
    50 "   Effects` (DAFx-00), pages 37–44, University of Verona, Italy, 2000.\n"
    51 "   (`online version <"
    52 "https://www.cs.princeton.edu/courses/archive/spr09/cos325/Bernardini.pdf"
    53 ">`_).\n"
    54 "";
    55 
     3static char Py_pvoc_doc[] = "pvoc object";
    564
    575typedef struct
    … …  
    174122static PyMemberDef Py_pvoc_members[] = {
    175123  {"win_s", T_INT, offsetof (Py_pvoc, win_s), READONLY,
    176     "int: Size of phase vocoder analysis windows, in samples.\n"
    177     ""},
     124    "size of the window"},
    178125  {"hop_s", T_INT, offsetof (Py_pvoc, hop_s), READONLY,
    179     "int: Interval between two analysis, in samples.\n"
    180     ""},
     126    "size of the hop"},
    181127  { NULL } // sentinel
    182128};
    … …  
    230176static PyMethodDef Py_pvoc_methods[] = {
    231177  {"rdo", (PyCFunction) Py_pvoc_rdo, METH_VARARGS,
    232     "rdo(fftgrain)\n"
    233     "\n"
    234     "Read a new spectral grain and resynthesise the next `hop_s`\n"
    235     "output samples.\n"
    236     "\n"
    237     "Parameters\n"
    238     "----------\n"
    239     "fftgrain : cvec\n"
    240     "    new input `cvec` to synthesize from, should be of size `win_s/2+1`\n"
    241     "\n"
    242     "Returns\n"
    243     "-------\n"
    244     "fvec\n"
    245     "    re-synthesised output of shape `(hop_s,)`\n"
    246     "\n"
    247     "Example\n"
    248     "-------\n"
    249     ">>> pv = aubio.pvoc(2048, 512)\n"
    250     ">>> out = pv.rdo(aubio.cvec(2048))\n"
    251     ">>> out.shape\n"
    252     "(512,)\n"
    253     ""},
    254   {"set_window", (PyCFunction) Pyaubio_pvoc_set_window, METH_VARARGS,
    255     "set_window(window_type)\n"
    256     "\n"
    257     "Set window function\n"
    258     "\n"
    259     "Parameters\n"
    260     "----------\n"
    261     "window_type : str\n"
    262     "    the window type to use for this phase vocoder\n"
    263     "\n"
    264     "Raises\n"
    265     "------\n"
    266     "ValueError\n"
    267     "    If an unknown window type was given.\n"
    268     "\n"
    269     "See Also\n"
    270     "--------\n"
    271     "window : create a window.\n"
    272     ""},
     178    "synthesis of spectral grain"},
     179  {"set_window", (PyCFunction) Pyaubio_pvoc_set_window, METH_VARARGS, ""},
    273180  {NULL}
    274181};

  • python/ext/py-sink.c

    r8986239 r152bf4f  
    1313
    1414static char Py_sink_doc[] = ""
    15 "sink(path, samplerate=44100, channels=1)\n"
    16 "\n"
    17 "Open `path` to write a WAV file.\n"
    18 "\n"
    19 "Parameters\n"
    20 "----------\n"
    21 "path : str\n"
    22 "   Pathname of the file to be opened for writing.\n"
    23 "samplerate : int\n"
    24 "   Sampling rate of the file, in Hz.\n"
    25 "channels : int\n"
    26 "   Number of channels to create the file with.\n"
    27 "\n"
    28 "Examples\n"
    29 "--------\n"
    30 "\n"
    31 "Create a new sink at 44100Hz, mono:\n"
    32 "\n"
    33 ">>> snk = aubio.sink('out.wav')\n"
    34 "\n"
    35 "Create a new sink at 32000Hz, stereo, write 100 samples into it:\n"
    36 "\n"
    37 ">>> snk = aubio.sink('out.wav', samplerate=16000, channels=3)\n"
    38 ">>> snk(aubio.fvec(100), 100)\n"
    39 "\n"
    40 "Open a new sink at 48000Hz, stereo, write `1234` samples into it:\n"
    41 "\n"
    42 ">>> with aubio.sink('out.wav', samplerate=48000, channels=2) as src:\n"
    43 "...     snk(aubio.fvec(1024), 1024)\n"
    44 "...     snk(aubio.fvec(210), 210)\n"
    45 "...\n"
    46 "\n"
    47 "See also\n"
    48 "--------\n"
    49 "source: read audio samples from a file.\n"
     15"  __new__(path, samplerate = 44100, channels = 1)\n"
     16"\n"
     17"      Create a new sink, opening the given path for writing.\n"
     18"\n"
     19"      Examples\n"
     20"      --------\n"
     21"\n"
     22"      Create a new sink at 44100Hz, mono:\n"
     23"\n"
     24"      >>> sink('/tmp/t.wav')\n"
     25"\n"
     26"      Create a new sink at 8000Hz, mono:\n"
     27"\n"
     28"      >>> sink('/tmp/t.wav', samplerate = 8000)\n"
     29"\n"
     30"      Create a new sink at 32000Hz, stereo:\n"
     31"\n"
     32"      >>> sink('/tmp/t.wav', samplerate = 32000, channels = 2)\n"
     33"\n"
     34"      Create a new sink at 32000Hz, 5 channels:\n"
     35"\n"
     36"      >>> sink('/tmp/t.wav', channels = 5, samplerate = 32000)\n"
     37"\n"
     38"  __call__(vec, write)\n"
     39"      x(vec,write) <==> x.do(vec, write)\n"
     40"\n"
     41"      Write vector to sink.\n"
     42"\n"
     43"      See also\n"
     44"      --------\n"
     45"      aubio.sink.do\n"
    5046"\n";
    5147
    5248static char Py_sink_do_doc[] = ""
    53 "do(vec, write)\n"
    54 "\n"
    55 "Write a single channel vector to sink.\n"
    56 "\n"
    57 "Parameters\n"
    58 "----------\n"
    59 "vec : fvec\n"
    60 "   input vector `(n,)` where `n >= 0`.\n"
    61 "write : int\n"
    62 "   Number of samples to write.\n"
    63 "";
     49"x.do(vec, write) <==> x(vec, write)\n"
     50"\n"
     51"write monophonic vector to sink";
    6452
    6553static char Py_sink_do_multi_doc[] = ""
    66 "do_multi(mat, write)\n"
    67 "\n"
    68 "Write a matrix containing vectors from multiple channels to sink.\n"
    69 "\n"
    70 "Parameters\n"
    71 "----------\n"
    72 "mat : numpy.ndarray\n"
    73 "   input matrix of shape `(channels, n)`, where `n >= 0`.\n"
    74 "write : int\n"
    75 "   Number of frames to write.\n"
    76 "";
     54"x.do_multi(mat, write)\n"
     55"\n"
     56"write polyphonic vector to sink";
    7757
    7858static char Py_sink_close_doc[] = ""
    79 "close()\n"
    80 "\n"
    81 "Close this sink now.\n"
    82 "\n"
    83 "By default, the sink will be closed before being deleted.\n"
    84 "Explicitely closing a sink can be useful to control the number\n"
    85 "of files simultaneously opened.\n"
    86 "";
     59"x.close()\n"
     60"\n"
     61"close this sink now";
    8762
    8863static PyObject *
    … …  
    214189static PyMemberDef Py_sink_members[] = {
    215190  {"uri", T_STRING, offsetof (Py_sink, uri), READONLY,
    216     "str (read-only): Path at which the sink was created."},
     191    "path at which the sink was created"},
    217192  {"samplerate", T_INT, offsetof (Py_sink, samplerate), READONLY,
    218     "int (read-only): Samplerate at which the sink was created."},
     193    "samplerate at which the sink was created"},
    219194  {"channels", T_INT, offsetof (Py_sink, channels), READONLY,
    220     "int (read-only): Number of channels with which the sink was created."},
     195    "number of channels with which the sink was created"},
    221196  { NULL } // sentinel
    222197};

  • python/ext/py-source.c

    r8986239 r152bf4f  
    1717
    1818static char Py_source_doc[] = ""
    19 "source(path, samplerate=0, hop_size=512, channels=0)\n"
    20 "\n"
    21 "Create a new source, opening the given pathname for reading.\n"
    22 "\n"
    23 "`source` open the file specified in `path` and creates a callable\n"
    24 "returning `hop_size` new audio samples at each invocation.\n"
    25 "\n"
    26 "If `samplerate=0` (default), the original sampling rate of `path`\n"
    27 "will be used. Otherwise, the output audio samples will be\n"
    28 "resampled at the desired sampling-rate.\n"
    29 "\n"
    30 "If `channels=0` (default), the original number of channels\n"
    31 "in `path` will be used. Otherwise, the output audio samples\n"
    32 "will be down-mixed or up-mixed to the desired number of\n"
    33 "channels.\n"
    34 "\n"
    35 "If `path` is a URL, a remote connection will be attempted to\n"
    36 "open the resource and stream data from it.\n"
    37 "\n"
    38 "The parameter `hop_size` determines how many samples should be\n"
    39 "read at each consecutive calls.\n"
    40 "\n"
    41 "Parameters\n"
    42 "----------\n"
    43 "path : str\n"
    44 "   pathname (or URL) of the file to be opened for reading\n"
    45 "samplerate : int, optional\n"
    46 "   sampling rate of the file\n"
    47 "hop_size : int, optional\n"
    48 "   number of samples to be read per iteration\n"
    49 "channels : int, optional\n"
    50 "   number of channels of the file\n"
    51 "\n"
    52 "Examples\n"
    53 "--------\n"
    54 "By default, when only `path` is given, the file will be opened\n"
    55 "with its original sampling rate and channel:\n"
    56 "\n"
    57 ">>> src = aubio.source('stereo.wav')\n"
    58 ">>> src.uri, src.samplerate, src.channels, src.duration\n"
    59 "('stereo.wav', 48000, 2, 86833)\n"
    60 "\n"
    61 "A typical loop to read all samples from a local file could\n"
    62 "look like this:\n"
    63 "\n"
    64 ">>> src = aubio.source('stereo.wav')\n"
    65 ">>> total_read = 0\n"
    66 ">>> while True:\n"
    67 "...     samples, read = src()\n"
    68 "...     # do something with samples\n"
    69 "...     total_read += read\n"
    70 "...     if read < src.hop_size:\n"
    71 "...         break\n"
    72 "...\n"
    73 "\n"
    74 "In a more Pythonic way, it can also look like this:\n"
    75 "\n"
    76 ">>> total_read = 0\n"
    77 ">>> with aubio.source('stereo.wav') as src:\n"
    78 "...     for frames in src:\n"
    79 "...         total_read += samples.shape[-1]\n"
    80 "...\n"
    81 "\n"
    82 ".. rubric:: Basic interface\n"
    83 "\n"
    84 "`source` is a **callable**; its :meth:`__call__` method\n"
    85 "returns a tuple containing:\n"
    86 "\n"
    87 "- a vector of shape `(hop_size,)`, filled with the `read` next\n"
    88 "  samples available, zero-padded if `read < hop_size`\n"
    89 "- `read`, an integer indicating the number of samples read\n"
    90 "\n"
    91 "To read the first `hop_size` samples from the source, simply call\n"
    92 "the instance itself, with no argument:\n"
    93 "\n"
    94 ">>> src = aubio.source('song.ogg')\n"
    95 ">>> samples, read = src()\n"
    96 ">>> samples.shape, read, src.hop_size\n"
    97 "((512,), 512, 512)\n"
    98 "\n"
    99 "The first call returned the slice of samples `[0 : hop_size]`.\n"
    100 "The next call will return samples `[hop_size: 2*hop_size]`.\n"
    101 "\n"
    102 "After several invocations of :meth:`__call__`, when reaching the end\n"
    103 "of the opened stream, `read` might become less than `hop_size`:\n"
    104 "\n"
    105 ">>> samples, read = src()\n"
    106 ">>> samples.shape, read\n"
    107 "((512,), 354)\n"
    108 "\n"
    109 "The end of the vector `samples` is filled with zeros.\n"
    110 "\n"
    111 "After the end of the stream, `read` will be `0` since no more\n"
    112 "samples are available:\n"
    113 "\n"
    114 ">>> samples, read = src()\n"
    115 ">>> samples.shape, read\n"
    116 "((512,), 0)\n"
    117 "\n"
    118 "**Note**: when the source has more than one channels, they\n"
    119 "are be down-mixed to mono when invoking :meth:`__call__`.\n"
    120 "To read from each individual channel, see :meth:`__next__`.\n"
    121 "\n"
    122 ".. rubric:: ``for`` statements\n"
    123 "\n"
    124 "The `source` objects are **iterables**. This allows using them\n"
    125 "directly in a ``for`` loop, which calls :meth:`__next__` until\n"
    126 "the end of the stream is reached:\n"
    127 "\n"
    128 ">>> src = aubio.source('stereo.wav')\n"
    129 ">>> for frames in src:\n"
    130 ">>>     print (frames.shape)\n"
    131 "...\n"
    132 "(2, 512)\n"
    133 "(2, 512)\n"
    134 "(2, 230)\n"
    135 "\n"
    136 "**Note**: When `next(self)` is called on a source with multiple\n"
    137 "channels, an array of shape `(channels, read)` is returned,\n"
    138 "unlike with :meth:`__call__` which always returns the down-mixed\n"
    139 "channels.\n"
    140 "\n"
    141 "If the file is opened with a single channel, `next(self)` returns\n"
    142 "an array of shape `(read,)`:\n"
    143 "\n"
    144 ">>> src = aubio.source('stereo.wav', channels=1)\n"
    145 ">>> next(src).shape\n"
    146 "(512,)\n"
    147 "\n"
    148 ".. rubric:: ``with`` statements\n"
    149 "\n"
    150 "The `source` objects are **context managers**, which allows using\n"
    151 "them in ``with`` statements:\n"
    152 "\n"
    153 ">>> with aubio.source('audiotrack.wav') as source:\n"
    154 "...     n_frames=0\n"
    155 "...     for samples in source:\n"
    156 "...         n_frames += len(samples)\n"
    157 "...     print('read', n_frames, 'samples in', samples.shape[0], 'channels',\n"
    158 "...         'from file \"\%s\"' \% source.uri)\n"
    159 "...\n"
    160 "read 239334 samples in 2 channels from file \"audiotrack.wav\"\n"
    161 "\n"
    162 "The file will be closed before exiting the statement.\n"
    163 "\n"
    164 "See also the methods implementing the context manager,\n"
    165 ":meth:`__enter__` and :meth:`__exit__`.\n"
    166 "\n"
    167 ".. rubric:: Seeking and closing\n"
    168 "\n"
    169 "At any time, :meth:`seek` can be used to move to any position in\n"
    170 "the file. For instance, to rewind to the start of the stream:\n"
    171 "\n"
    172 ">>> src.seek(0)\n"
    173 "\n"
    174 "The opened file will be automatically closed when the object falls\n"
    175 "out of scope and is scheduled for garbage collection.\n"
    176 "\n"
    177 "In some cases, it is useful to manually :meth:`close` a given source,\n"
    178 "for instance to limit the number of simultaneously opened files:\n"
    179 "\n"
    180 ">>> src.close()\n"
    181 "\n"
    182 ".. rubric:: Input formats\n"
    183 "\n"
    184 "Depending on how aubio was compiled, :class:`source` may or may not\n"
    185 "open certain **files format**. Below are some examples that assume\n"
    186 "support for compressed files and remote urls was compiled in:\n"
    187 "\n"
    188 "- open a local file using its original sampling rate and channels,\n"
    189 "  and with the default hop size:\n"
    190 "\n"
    191 ">>> s = aubio.source('sample.wav')\n"
    192 ">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
    193 "('sample.wav', 44100, 2, 512)\n"
    194 "\n"
    195 "- open a local compressed audio file, resampling to 32000Hz if needed:\n"
    196 "\n"
    197 ">>> s = aubio.source('song.mp3', samplerate=32000)\n"
    198 ">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
    199 "('song.mp3', 32000, 2, 512)\n"
    200 "\n"
    201 "- open a local video file, down-mixing and resampling it to 16kHz:\n"
    202 "\n"
    203 ">>> s = aubio.source('movie.mp4', samplerate=16000, channels=1)\n"
    204 ">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
    205 "('movie.mp4', 16000, 1, 512)\n"
    206 "\n"
    207 "- open a remote resource, with hop_size = 1024:\n"
    208 "\n"
    209 ">>> s = aubio.source('https://aubio.org/drum.ogg', hop_size=1024)\n"
    210 ">>> s.uri, s.samplerate, s.channels, s.hop_size\n"
    211 "('https://aubio.org/drum.ogg', 48000, 2, 1024)\n"
    212 "\n"
    213 "See Also\n"
    214 "--------\n"
    215 "sink: write audio samples to a file.\n"
    216 "";
     19"   __new__(path, samplerate = 0, hop_size = 512, channels = 1)\n"
     20"\n"
     21"       Create a new source, opening the given path for reading.\n"
     22"\n"
     23"       Examples\n"
     24"       --------\n"
     25"\n"
     26"       Create a new source, using the original samplerate, with hop_size = 512:\n"
     27"\n"
     28"       >>> source('/tmp/t.wav')\n"
     29"\n"
     30"       Create a new source, resampling the original to 8000Hz:\n"
     31"\n"
     32"       >>> source('/tmp/t.wav', samplerate = 8000)\n"
     33"\n"
     34"       Create a new source, resampling it at 32000Hz, hop_size = 32:\n"
     35"\n"
     36"       >>> source('/tmp/t.wav', samplerate = 32000, hop_size = 32)\n"
     37"\n"
     38"       Create a new source, using its original samplerate:\n"
     39"\n"
     40"       >>> source('/tmp/t.wav', samplerate = 0)\n"
     41"\n"
     42"   __call__()\n"
     43"       vec, read = x() <==> vec, read = x.do()\n"
     44"\n"
     45"       Read vector from source.\n"
     46"\n"
     47"       See also\n"
     48"       --------\n"
     49"       aubio.source.do\n"
     50"\n";
    21751
    21852static char Py_source_get_samplerate_doc[] = ""
    219 "get_samplerate()\n"
    220 "\n"
    221 "Get sampling rate of source.\n"
    222 "\n"
    223 "Returns\n"
    224 "-------\n"
    225 "int\n"
    226 "    Sampling rate, in Hz.\n"
    227 "";
     53"x.get_samplerate() -> source samplerate\n"
     54"\n"
     55"Get samplerate of source.";
    22856
    22957static char Py_source_get_channels_doc[] = ""
    230 "get_channels()\n"
    231 "\n"
    232 "Get number of channels in source.\n"
    233 "\n"
    234 "Returns\n"
    235 "-------\n"
    236 "int\n"
    237 "    Number of channels.\n"
    238 "";
     58"x.get_channels() -> number of channels\n"
     59"\n"
     60"Get number of channels in source.";
    23961
    24062static char Py_source_do_doc[] = ""
    241 "source.do()\n"
    242 "\n"
    243 "Read vector of audio samples.\n"
    244 "\n"
    245 "If the audio stream in the source has more than one channel,\n"
    246 "the channels will be down-mixed.\n"
    247 "\n"
    248 "Returns\n"
    249 "-------\n"
    250 "samples : numpy.ndarray, shape `(hop_size,)`, dtype aubio.float_type\n"
    251 "    `fvec` of size `hop_size` containing the new samples.\n"
    252 "read : int\n"
    253 "    Number of samples read from the source, equals to `hop_size`\n"
    254 "    before the end-of-file is reached, less when it is reached,\n"
    255 "    and `0` after.\n"
    256 "\n"
    257 "See Also\n"
    258 "--------\n"
    259 "do_multi\n"
    260 "\n"
    261 "Examples\n"
    262 "--------\n"
    263 ">>> src = aubio.source('sample.wav', hop_size=1024)\n"
    264 ">>> src.do()\n"
    265 "(array([-0.00123001, -0.00036685,  0.00097106, ..., -0.2031033 ,\n"
    266 "       -0.2025854 , -0.20221856], dtype=" AUBIO_NPY_SMPL_STR "), 1024)\n"
    267 "";
     63"vec, read = x.do() <==> vec, read = x()\n"
     64"\n"
     65"Read monophonic vector from source.";
    26866
    26967static char Py_source_do_multi_doc[] = ""
    270 "do_multi()\n"
    271 "\n"
    272 "Read multiple channels of audio samples.\n"
    273 "\n"
    274 "If the source was opened with the same number of channels\n"
    275 "found in the stream, each channel will be read individually.\n"
    276 "\n"
    277 "If the source was opened with less channels than the number\n"
    278 "of channels in the stream, only the first channels will be read.\n"
    279 "\n"
    280 "If the source was opened with more channels than the number\n"
    281 "of channel in the original stream, the first channels will\n"
    282 "be duplicated on the additional output channel.\n"
    283 "\n"
    284 "Returns\n"
    285 "-------\n"
    286 "samples : np.ndarray([hop_size, channels], dtype=aubio.float_type)\n"
    287 "    NumPy array of shape `(hop_size, channels)` containing the new\n"
    288 "    audio samples.\n"
    289 "read : int\n"
    290 "    Number of samples read from the source, equals to `hop_size`\n"
    291 "    before the end-of-file is reached, less when it is reached,\n"
    292 "    and `0` after.\n"
    293 "\n"
    294 "See Also\n"
    295 "--------\n"
    296 "do\n"
    297 "\n"
    298 "Examples\n"
    299 "--------\n"
    300 ">>> src = aubio.source('sample.wav')\n"
    301 ">>> src.do_multi()\n"
    302 "(array([[ 0.00668335,  0.0067749 ,  0.00714111, ..., -0.05737305,\n"
    303 "        -0.05856323, -0.06018066],\n"
    304 "       [-0.00842285, -0.0072937 , -0.00576782, ..., -0.09405518,\n"
    305 "        -0.09558105, -0.09725952]], dtype=" AUBIO_NPY_SMPL_STR "), 512)\n"
    306 "";
     68"mat, read = x.do_multi()\n"
     69"\n"
     70"Read polyphonic vector from source.";
    30771
    30872static char Py_source_close_doc[] = ""
    309 "close()\n"
    310 "\n"
    311 "Close this source now.\n"
    312 "\n"
    313 ".. note:: Closing twice a source will **not** raise any exception.\n"
    314 "";
     73"x.close()\n"
     74"\n"
     75"Close this source now.";
    31576
    31677static char Py_source_seek_doc[] = ""
    317 "seek(position)\n"
    318 "\n"
    319 "Seek to position in file.\n"
    320 "\n"
    321 "If the source was not opened with its original sampling-rate,\n"
    322 "`position` corresponds to the position in the re-sampled file.\n"
    323 "\n"
    324 "Parameters\n"
    325 "----------\n"
    326 "position : str\n"
    327 "   position to seek to, in samples\n"
    328 "";
     78"x.seek(position)\n"
     79"\n"
     80"Seek to resampled frame position.";
    32981
    33082static PyObject *
    … …  
    466218static PyMemberDef Py_source_members[] = {
    467219  {"uri", T_STRING, offsetof (Py_source, uri), READONLY,
    468     "str (read-only): pathname or URL"},
     220    "path at which the source was created"},
    469221  {"samplerate", T_INT, offsetof (Py_source, samplerate), READONLY,
    470     "int (read-only): sampling rate"},
     222    "samplerate at which the source is viewed"},
    471223  {"channels", T_INT, offsetof (Py_source, channels), READONLY,
    472     "int (read-only): number of channels"},
     224    "number of channels found in the source"},
    473225  {"hop_size", T_INT, offsetof (Py_source, hop_size), READONLY,
    474     "int (read-only): number of samples read per iteration"},
     226    "number of consecutive frames that will be read at each do or do_multi call"},
    475227  {"duration", T_INT, offsetof (Py_source, duration), READONLY,
    476     "int (read-only): total number of frames in the source\n"
    477     "\n"
    478     "Can be estimated, for instance if the opened stream is\n"
    479     "a compressed media or a remote resource.\n"
    480     "\n"
    481     "Example\n"
    482     "-------\n"
    483     ">>> n = 0\n"
    484     ">>> src = aubio.source('track1.mp3')\n"
    485     ">>> for samples in src:\n"
    486     "...     n += samples.shape[-1]\n"
    487     "...\n"
    488     ">>> n, src.duration\n"
    489     "(9638784, 9616561)\n"
    490     ""},
     228    "total number of frames in the source (estimated)"},
    491229  { NULL } // sentinel
    492230};

  • python/ext/ufuncs.c

    r8986239 r152bf4f  
    5959};
    6060
    61 // Note: these docstrings should *not* include the function signatures
    62 
    63 static char Py_unwrap2pi_doc[] = ""
    64 "\n"
    65 "Map angle to unit circle :math:`[-\\pi, \\pi[`.\n"
    66 "\n"
    67 "Parameters\n"
    68 "----------\n"
    69 "x : numpy.ndarray\n"
    70 "   input array\n"
    71 "\n"
    72 "Returns\n"
    73 "-------\n"
    74 "numpy.ndarray\n"
    75 "   values clamped to the unit circle :math:`[-\\pi, \\pi[`\n"
    76 "";
     61static char Py_unwrap2pi_doc[] = "map angle to unit circle [-pi, pi[";
    7762
    7863static void* Py_unwrap2pi_data[] = {
    … …  
    8368};
    8469
    85 static char Py_freqtomidi_doc[] = ""
    86 "\n"
    87 "Convert frequency `[0; 23000[` to midi `[0; 128[`.\n"
    88 "\n"
    89 "Parameters\n"
    90 "----------\n"
    91 "x : numpy.ndarray\n"
    92 "    Array of frequencies, in Hz.\n"
    93 "\n"
    94 "Returns\n"
    95 "-------\n"
    96 "numpy.ndarray\n"
    97 "    Converted frequencies, in midi note.\n"
    98 "";
     70static char Py_freqtomidi_doc[] = "convert frequency to midi";
    9971
    10072static void* Py_freqtomidi_data[] = {
    … …  
    10375};
    10476
    105 static char Py_miditofreq_doc[] = ""
    106 "\n"
    107 "Convert midi `[0; 128[` to frequency `[0, 23000]`.\n"
    108 "\n"
    109 "Parameters\n"
    110 "----------\n"
    111 "x : numpy.ndarray\n"
    112 "    Array of frequencies, in midi note.\n"
    113 "\n"
    114 "Returns\n"
    115 "-------\n"
    116 "numpy.ndarray\n"
    117 "    Converted frequencies, in Hz\n"
    118 "";
     77static char Py_miditofreq_doc[] = "convert midi to frequency";
    11978
    12079static void* Py_miditofreq_data[] = {
Note: See TracChangeset for help on using the changeset viewer.