python/ext/aubiomodule.c: fix PyMethodDef sentinel
[aubio.git] / python / ext / aubiomodule.c
1 #define PY_AUBIO_MODULE_MAIN
2 #include "aubio-types.h"
3 #include "py-musicutils.h"
4
5 static char aubio_module_doc[] = "Python module for the aubio library";
6
7 static char Py_alpha_norm_doc[] = ""
8 "alpha_norm(fvec, integer) -> float\n"
9 "\n"
10 "Compute alpha normalisation factor on vector, given alpha\n"
11 "\n"
12 "Example\n"
13 "-------\n"
14 "\n"
15 ">>> b = alpha_norm(a, 9)";
16
17 static char Py_bintomidi_doc[] = ""
18 "bintomidi(float, samplerate = integer, fftsize = integer) -> float\n"
19 "\n"
20 "Convert bin (float) to midi (float), given the sampling rate and the FFT size\n"
21 "\n"
22 "Example\n"
23 "-------\n"
24 "\n"
25 ">>> midi = bintomidi(float, samplerate = 44100, fftsize = 1024)";
26
27 static char Py_miditobin_doc[] = ""
28 "miditobin(float, samplerate = integer, fftsize = integer) -> float\n"
29 "\n"
30 "Convert midi (float) to bin (float), given the sampling rate and the FFT size\n"
31 "\n"
32 "Example\n"
33 "-------\n"
34 "\n"
35 ">>> bin = miditobin(midi, samplerate = 44100, fftsize = 1024)";
36
37 static char Py_bintofreq_doc[] = ""
38 "bintofreq(float, samplerate = integer, fftsize = integer) -> float\n"
39 "\n"
40 "Convert bin number (float) in frequency (Hz), given the sampling rate and the FFT size\n"
41 "\n"
42 "Example\n"
43 "-------\n"
44 "\n"
45 ">>> freq = bintofreq(bin, samplerate = 44100, fftsize = 1024)";
46
47 static char Py_freqtobin_doc[] = ""
48 "freqtobin(float, samplerate = integer, fftsize = integer) -> float\n"
49 "\n"
50 "Convert frequency (Hz) in bin number (float), given the sampling rate and the FFT size\n"
51 "\n"
52 "Example\n"
53 "-------\n"
54 "\n"
55 ">>> bin = freqtobin(freq, samplerate = 44100, fftsize = 1024)";
56
57 static char Py_zero_crossing_rate_doc[] = ""
58 "zero_crossing_rate(fvec) -> float\n"
59 "\n"
60 "Compute Zero crossing rate of a vector\n"
61 "\n"
62 "Example\n"
63 "-------\n"
64 "\n"
65 ">>> z = zero_crossing_rate(a)";
66
67 static char Py_min_removal_doc[] = ""
68 "min_removal(fvec) -> float\n"
69 "\n"
70 "Remove the minimum value of a vector, in-place modification\n"
71 "\n"
72 "Example\n"
73 "-------\n"
74 "\n"
75 ">>> min_removal(a)";
76
77 extern void add_generated_objects ( PyObject *m );
78 extern void add_ufuncs ( PyObject *m );
79 extern int generated_types_ready(void);
80
81 static PyObject *
82 Py_alpha_norm (PyObject * self, PyObject * args)
83 {
84   PyObject *input;
85   fvec_t vec;
86   smpl_t alpha;
87   PyObject *result;
88
89   if (!PyArg_ParseTuple (args, "O" AUBIO_NPY_SMPL_CHR ":alpha_norm", &input, &alpha)) {
90     return NULL;
91   }
92
93   if (input == NULL) {
94     return NULL;
95   }
96
97   if (!PyAubio_ArrayToCFvec(input, &vec)) {
98     return NULL;
99   }
100
101   // compute the function
102   result = Py_BuildValue (AUBIO_NPY_SMPL_CHR, fvec_alpha_norm (&vec, alpha));
103   if (result == NULL) {
104     return NULL;
105   }
106
107   return result;
108 }
109
110 static PyObject *
111 Py_bintomidi (PyObject * self, PyObject * args)
112 {
113   smpl_t input, samplerate, fftsize;
114   smpl_t output;
115
116   if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
117     return NULL;
118   }
119
120   output = aubio_bintomidi (input, samplerate, fftsize);
121
122   return (PyObject *)PyFloat_FromDouble (output);
123 }
124
125 static PyObject *
126 Py_miditobin (PyObject * self, PyObject * args)
127 {
128   smpl_t input, samplerate, fftsize;
129   smpl_t output;
130
131   if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
132     return NULL;
133   }
134
135   output = aubio_miditobin (input, samplerate, fftsize);
136
137   return (PyObject *)PyFloat_FromDouble (output);
138 }
139
140 static PyObject *
141 Py_bintofreq (PyObject * self, PyObject * args)
142 {
143   smpl_t input, samplerate, fftsize;
144   smpl_t output;
145
146   if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
147     return NULL;
148   }
149
150   output = aubio_bintofreq (input, samplerate, fftsize);
151
152   return (PyObject *)PyFloat_FromDouble (output);
153 }
154
155 static PyObject *
156 Py_freqtobin (PyObject * self, PyObject * args)
157 {
158   smpl_t input, samplerate, fftsize;
159   smpl_t output;
160
161   if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
162     return NULL;
163   }
164
165   output = aubio_freqtobin (input, samplerate, fftsize);
166
167   return (PyObject *)PyFloat_FromDouble (output);
168 }
169
170 static PyObject *
171 Py_zero_crossing_rate (PyObject * self, PyObject * args)
172 {
173   PyObject *input;
174   fvec_t vec;
175   PyObject *result;
176
177   if (!PyArg_ParseTuple (args, "O:zero_crossing_rate", &input)) {
178     return NULL;
179   }
180
181   if (input == NULL) {
182     return NULL;
183   }
184
185   if (!PyAubio_ArrayToCFvec(input, &vec)) {
186     return NULL;
187   }
188
189   // compute the function
190   result = Py_BuildValue (AUBIO_NPY_SMPL_CHR, aubio_zero_crossing_rate (&vec));
191   if (result == NULL) {
192     return NULL;
193   }
194
195   return result;
196 }
197
198 static PyObject *
199 Py_min_removal(PyObject * self, PyObject * args)
200 {
201   PyObject *input;
202   fvec_t vec;
203
204   if (!PyArg_ParseTuple (args, "O:min_removal", &input)) {
205     return NULL;
206   }
207
208   if (input == NULL) {
209     return NULL;
210   }
211
212   if (!PyAubio_ArrayToCFvec(input, &vec)) {
213     return NULL;
214   }
215
216   // compute the function
217   fvec_min_removal (&vec);
218
219   // since this function does not return, we could return None
220   //Py_RETURN_NONE;
221   // however it is convenient to return the modified vector
222   return (PyObject *) PyAubio_CFvecToArray(&vec);
223   // or even without converting it back to an array
224   //Py_INCREF(vec);
225   //return (PyObject *)vec;
226 }
227
228 static PyMethodDef aubio_methods[] = {
229   {"bintomidi", Py_bintomidi, METH_VARARGS, Py_bintomidi_doc},
230   {"miditobin", Py_miditobin, METH_VARARGS, Py_miditobin_doc},
231   {"bintofreq", Py_bintofreq, METH_VARARGS, Py_bintofreq_doc},
232   {"freqtobin", Py_freqtobin, METH_VARARGS, Py_freqtobin_doc},
233   {"alpha_norm", Py_alpha_norm, METH_VARARGS, Py_alpha_norm_doc},
234   {"zero_crossing_rate", Py_zero_crossing_rate, METH_VARARGS, Py_zero_crossing_rate_doc},
235   {"min_removal", Py_min_removal, METH_VARARGS, Py_min_removal_doc},
236   {"level_lin", Py_aubio_level_lin, METH_VARARGS, Py_aubio_level_lin_doc},
237   {"db_spl", Py_aubio_db_spl, METH_VARARGS, Py_aubio_db_spl_doc},
238   {"silence_detection", Py_aubio_silence_detection, METH_VARARGS, Py_aubio_silence_detection_doc},
239   {"level_detection", Py_aubio_level_detection, METH_VARARGS, Py_aubio_level_detection_doc},
240   {"window", Py_aubio_window, METH_VARARGS, Py_aubio_window_doc},
241   {NULL, NULL, 0, NULL} /* Sentinel */
242 };
243
244 #if PY_MAJOR_VERSION >= 3
245 // Python3 module definition
246 static struct PyModuleDef moduledef = {
247    PyModuleDef_HEAD_INIT,
248    "_aubio",          /* m_name */
249    aubio_module_doc,  /* m_doc */
250    -1,                /* m_size */
251    aubio_methods,     /* m_methods */
252    NULL,              /* m_reload */
253    NULL,              /* m_traverse */
254    NULL,              /* m_clear */
255    NULL,              /* m_free */
256 };
257 #endif
258
259 static PyObject *
260 initaubio (void)
261 {
262   PyObject *m = NULL;
263   int err;
264
265   // fvec is defined in __init__.py
266   if (   (PyType_Ready (&Py_cvecType) < 0)
267       || (PyType_Ready (&Py_filterType) < 0)
268       || (PyType_Ready (&Py_filterbankType) < 0)
269       || (PyType_Ready (&Py_fftType) < 0)
270       || (PyType_Ready (&Py_pvocType) < 0)
271       || (PyType_Ready (&Py_sourceType) < 0)
272       || (PyType_Ready (&Py_sinkType) < 0)
273       // generated objects
274       || (generated_types_ready() < 0 )
275   ) {
276     return m;
277   }
278
279 #if PY_MAJOR_VERSION >= 3
280   m = PyModule_Create(&moduledef);
281 #else
282   m = Py_InitModule3 ("_aubio", aubio_methods, aubio_module_doc);
283 #endif
284
285   if (m == NULL) {
286     return m;
287   }
288
289   err = _import_array ();
290   if (err != 0) {
291     fprintf (stderr,
292         "Unable to import Numpy array from aubio module (error %d)\n", err);
293   }
294
295   Py_INCREF (&Py_cvecType);
296   PyModule_AddObject (m, "cvec", (PyObject *) & Py_cvecType);
297   Py_INCREF (&Py_filterType);
298   PyModule_AddObject (m, "digital_filter", (PyObject *) & Py_filterType);
299   Py_INCREF (&Py_filterbankType);
300   PyModule_AddObject (m, "filterbank", (PyObject *) & Py_filterbankType);
301   Py_INCREF (&Py_fftType);
302   PyModule_AddObject (m, "fft", (PyObject *) & Py_fftType);
303   Py_INCREF (&Py_pvocType);
304   PyModule_AddObject (m, "pvoc", (PyObject *) & Py_pvocType);
305   Py_INCREF (&Py_sourceType);
306   PyModule_AddObject (m, "source", (PyObject *) & Py_sourceType);
307   Py_INCREF (&Py_sinkType);
308   PyModule_AddObject (m, "sink", (PyObject *) & Py_sinkType);
309
310   PyModule_AddStringConstant(m, "float_type", AUBIO_NPY_SMPL_STR);
311
312   // add generated objects
313   add_generated_objects(m);
314
315   // add ufunc
316   add_ufuncs(m);
317
318   return m;
319 }
320
321 #if PY_MAJOR_VERSION >= 3
322     // Python3 init
323     PyMODINIT_FUNC PyInit__aubio(void)
324     {
325         return initaubio();
326     }
327 #else
328     // Python 2 init
329     PyMODINIT_FUNC init_aubio(void)
330     {
331         initaubio();
332     }
333 #endif