source: python/lib/gen_code.py @ 8470144

feature/autosinkfeature/cnnfeature/cnn_orgfeature/constantqfeature/crepefeature/crepe_orgfeature/pitchshiftfeature/pydocstringsfeature/timestretchfix/ffmpeg5pitchshiftsamplertimestretchyinfft+
Last change on this file since 8470144 was 8470144, checked in by Paul Brossier <piem@piem.org>, 8 years ago

python/lib/gen_code.py: add output size for notes

  • Property mode set to 100644
File size: 15.7 KB
Line 
1aubiodefvalue = {
2    # we have some clean up to do
3    'buf_size': 'Py_default_vector_length',
4    'win_s': 'Py_default_vector_length',
5    # and here too
6    'hop_size': 'Py_default_vector_length / 2',
7    'hop_s': 'Py_default_vector_length / 2',
8    # these should be alright
9    'samplerate': 'Py_aubio_default_samplerate',
10    # now for the non obvious ones
11    'n_filters': '40',
12    'n_coeffs': '13',
13    'nelems': '10',
14    'flow': '0.',
15    'fhig': '1.',
16    'ilow': '0.',
17    'ihig': '1.',
18    'thrs': '0.5',
19    'ratio': '0.5',
20    'method': '"default"',
21    'uri': '"none"',
22    }
23
24member_types = {
25        'name': 'type',
26        'char_t*': 'T_STRING',
27        'uint_t': 'T_INT',
28        'smpl_t': 'AUBIO_NPY_SMPL',
29        }
30
31pyfromtype_fn = {
32        'smpl_t': 'PyFloat_FromDouble',
33        'uint_t': 'PyLong_FromLong', # was: 'PyInt_FromLong',
34        'fvec_t*': 'PyAubio_CFvecToArray',
35        'fmat_t*': 'PyAubio_CFmatToArray',
36        }
37
38pytoaubio_fn = {
39        'fvec_t*': 'PyAubio_ArrayToCFvec',
40        'cvec_t*': 'PyAubio_PyCvecToCCvec',
41        #'fmat_t*': 'PyAubio_ArrayToCFmat',
42        }
43
44newfromtype_fn = {
45        'fvec_t*': 'new_py_fvec',
46        'fmat_t*': 'new_py_fmat',
47        'cvec_t*': 'new_py_cvec',
48        }
49
50delfromtype_fn = {
51        'fvec_t*': 'Py_DECREF',
52        'fmat_t*': 'Py_DECREF',
53        'cvec_t*': 'Py_DECREF',
54        }
55
56param_init = {
57        'char_t*': 'NULL',
58        'uint_t': '0',
59        'sint_t': 0,
60        'smpl_t': 0.,
61        'lsmp_t': 0.,
62        }
63
64pyargparse_chars = {
65        'smpl_t': 'f', # if not usedouble else 'd',
66        'uint_t': 'I',
67        'sint_t': 'I',
68        'char_t*': 's',
69        'fmat_t*': 'O',
70        'fvec_t*': 'O',
71        'cvec_t*': 'O',
72        }
73
74objoutsize = {
75        'onset': '1',
76        'pitch': '1',
77        'notes': '3',
78        'wavetable': 'self->hop_size',
79        'sampler': 'self->hop_size',
80        'mfcc': 'self->n_coeffs',
81        'specdesc': '1',
82        'tempo': '1',
83        'filterbank': 'self->n_filters',
84        'tss': 'self->hop_size',
85        }
86
87def get_name(proto):
88    name = proto.replace(' *', '* ').split()[1].split('(')[0]
89    name = name.replace('*','')
90    if name == '': raise ValueError(proto + "gave empty name")
91    return name
92
93def get_return_type(proto):
94    import re
95    paramregex = re.compile('(\w+ ?\*?).*')
96    outputs = paramregex.findall(proto)
97    assert len(outputs) == 1
98    return outputs[0].replace(' ', '')
99
100def split_type(arg):
101    """ arg = 'foo *name'
102        return ['foo*', 'name'] """
103    l = arg.split()
104    type_arg = {} #'type': l[0], 'name': l[1]}
105    type_arg['type'] = " ".join(l[:-1])
106    type_arg['name'] = l[-1]
107    # fix up type / name
108    if type_arg['name'].startswith('*'):
109        # ['foo', '*name'] -> ['foo*', 'name']
110        type_arg['type'] += '*'
111        type_arg['name'] = type_arg['name'][1:]
112    if type_arg['type'].endswith(' *'):
113        # ['foo *', 'name'] -> ['foo*', 'name']
114        type_arg['type'] = type_arg['type'].replace(' *','*')
115    if type_arg['type'].startswith('const '):
116        # ['foo *', 'name'] -> ['foo*', 'name']
117        type_arg['type'] = type_arg['type'].replace('const ','')
118    return type_arg
119
120def get_params(proto):
121    """ get the list of parameters from a function prototype
122    example: proto = "int main (int argc, char ** argv)"
123    returns: ['int argc', 'char ** argv']
124    """
125    import re
126    paramregex = re.compile('.*\((.*)\);')
127    a = paramregex.findall(proto)[0].split(', ')
128    #a = [i.replace('const ', '') for i in a]
129    return a
130
131def get_input_params(proto):
132    a = get_params(proto)
133    return [i.replace('const ', '') for i in a if (i.startswith('const ') or i.startswith('uint_t ') or i.startswith('smpl_t '))]
134
135def get_output_params(proto):
136    a = get_params(proto)
137    return [i for i in a if not i.startswith('const ')][1:]
138
139def get_params_types_names(proto):
140    """ get the list of parameters from a function prototype
141    example: proto = "int main (int argc, char ** argv)"
142    returns: [['int', 'argc'], ['char **','argv']]
143    """
144    a = list(map(split_type, get_params(proto)))
145    #print proto, a
146    #import sys; sys.exit(1)
147    return a
148
149class MappedObject(object):
150
151    def __init__(self, prototypes, usedouble = False):
152        if usedouble:
153            pyargparse_chars['smpl_t'] = 'd'
154        self.prototypes = prototypes
155
156        self.shortname = prototypes['shortname']
157        self.longname = prototypes['longname']
158        self.new_proto = prototypes['new'][0]
159        self.del_proto = prototypes['del'][0]
160        self.do_proto = prototypes['do'][0]
161        self.input_params = get_params_types_names(self.new_proto)
162        self.input_params_list = "; ".join(get_input_params(self.new_proto))
163        self.outputs = get_params_types_names(self.do_proto)[2:]
164        self.do_inputs = [get_params_types_names(self.do_proto)[1]]
165        self.do_outputs = get_params_types_names(self.do_proto)[2:]
166        struct_output_str = ["PyObject *{0[name]}; {1} c_{0[name]}".format(i, i['type'][:-1]) for i in self.do_outputs]
167        self.struct_outputs = ";\n    ".join(struct_output_str)
168
169        #print ("input_params: ", map(split_type, get_input_params(self.do_proto)))
170        #print ("output_params", map(split_type, get_output_params(self.do_proto)))
171
172    def gen_code(self):
173        out = ""
174        out += self.gen_struct()
175        out += self.gen_doc()
176        out += self.gen_new()
177        out += self.gen_init()
178        out += self.gen_del()
179        out += self.gen_do()
180        out += self.gen_memberdef()
181        out += self.gen_set()
182        out += self.gen_get()
183        out += self.gen_methodef()
184        out += self.gen_typeobject()
185        return out
186
187    def gen_struct(self):
188        out = """
189// {shortname} structure
190typedef struct{{
191    PyObject_HEAD
192    // pointer to aubio object
193    {longname} *o;
194    // input parameters
195    {input_params_list};
196    // do input vectors
197    {do_inputs_list};
198    // output results
199    {struct_outputs};
200}} Py_{shortname};
201"""
202        # fmat_t* / fvec_t* / cvec_t* inputs -> full fvec_t /.. struct in Py_{shortname}
203        do_inputs_list = "; ".join(get_input_params(self.do_proto)).replace('fvec_t *','fvec_t').replace('fmat_t *', 'fmat_t').replace('cvec_t *', 'cvec_t')
204        return out.format(do_inputs_list = do_inputs_list, **self.__dict__)
205
206    def gen_doc(self):
207        out = """
208// TODO: add documentation
209static char Py_{shortname}_doc[] = \"undefined\";
210"""
211        return out.format(**self.__dict__)
212
213    def gen_new(self):
214        out = """
215// new {shortname}
216static PyObject *
217Py_{shortname}_new (PyTypeObject * pytype, PyObject * args, PyObject * kwds)
218{{
219    Py_{shortname} *self;
220""".format(**self.__dict__)
221        params = self.input_params
222        for p in params:
223            out += """
224    {type} {name} = {defval};""".format(defval = param_init[p['type']], **p)
225        plist = ", ".join(["\"%s\"" % p['name'] for p in params])
226        out += """
227    static char *kwlist[] = {{ {plist}, NULL }};""".format(plist = plist)
228        argchars = "".join([pyargparse_chars[p['type']] for p in params])
229        arglist = ", ".join(["&%s" % p['name'] for p in params])
230        out += """
231    if (!PyArg_ParseTupleAndKeywords (args, kwds, "|{argchars}", kwlist,
232              {arglist})) {{
233        return NULL;
234    }}
235""".format(argchars = argchars, arglist = arglist)
236        out += """
237    self = (Py_{shortname} *) pytype->tp_alloc (pytype, 0);
238    if (self == NULL) {{
239        return NULL;
240    }}
241""".format(**self.__dict__)
242        params = self.input_params
243        for p in params:
244            out += self.check_valid(p)
245        out += """
246    return (PyObject *)self;
247}
248"""
249        return out
250
251    def check_valid(self, p):
252        if p['type'] == 'uint_t':
253            return self.check_valid_uint(p)
254        if p['type'] == 'char_t*':
255            return self.check_valid_char(p)
256        else:
257            print ("ERROR, no idea how to check %s for validity" % p['type'])
258
259    def check_valid_uint(self, p):
260        name = p['name']
261        return """
262    self->{name} = {defval};
263    if ((sint_t){name} > 0) {{
264        self->{name} = {name};
265    }} else if ((sint_t){name} < 0) {{
266        PyErr_SetString (PyExc_ValueError, "can not use negative value for {name}");
267        return NULL;
268    }}
269""".format(defval = aubiodefvalue[name], name = name)
270
271    def check_valid_char(self, p):
272        name = p['name']
273        return """
274    self->{name} = {defval};
275    if ({name} != NULL) {{
276        self->{name} = {name};
277    }}
278""".format(defval = aubiodefvalue[name], name = name)
279
280    def gen_init(self):
281        out = """
282// init {shortname}
283static int
284Py_{shortname}_init (Py_{shortname} * self, PyObject * args, PyObject * kwds)
285{{
286""".format(**self.__dict__)
287        new_name = get_name(self.new_proto)
288        new_params = ", ".join(["self->%s" % s['name'] for s in self.input_params])
289        out += """
290  self->o = {new_name}({new_params});
291""".format(new_name = new_name, new_params = new_params)
292        paramchars = "%s"
293        paramvals = "self->method"
294        out += """
295  // return -1 and set error string on failure
296  if (self->o == NULL) {{
297    PyErr_Format (PyExc_Exception, "failed creating {shortname}");
298    return -1;
299  }}
300""".format(paramchars = paramchars, paramvals = paramvals, **self.__dict__)
301        output_create = ""
302        for o in self.outputs:
303            output_create += """
304  self->{name} = {create_fn}({output_size});""".format(name = o['name'], create_fn = newfromtype_fn[o['type']], output_size = objoutsize[self.shortname])
305        out += """
306  // TODO get internal params after actual object creation?
307"""
308        out += """
309  // create outputs{output_create}
310""".format(output_create = output_create)
311        out += """
312  return 0;
313}
314"""
315        return out
316
317    def gen_memberdef(self):
318        out = """
319static PyMemberDef Py_{shortname}_members[] = {{
320""".format(**self.__dict__)
321        for p in get_params_types_names(self.new_proto):
322            tmp = "  {{\"{name}\", {ttype}, offsetof (Py_{shortname}, {name}), READONLY, \"TODO documentation\"}},\n"
323            pytype = member_types[p['type']]
324            out += tmp.format(name = p['name'], ttype = pytype, shortname = self.shortname)
325        out += """  {NULL}, // sentinel
326};
327"""
328        return out
329
330    def gen_del(self):
331        out = """
332// del {shortname}
333static void
334Py_{shortname}_del  (Py_{shortname} * self, PyObject * unused)
335{{""".format(**self.__dict__)
336        for input_param in self.do_inputs:
337            if input_param['type'] == 'fmat_t *':
338                out += """
339    free(self->{0[name]}.data);""".format(input_param)
340        for o in self.outputs:
341            name = o['name']
342            del_out = delfromtype_fn[o['type']]
343            out += """
344    {del_out}(self->{name});""".format(del_out = del_out, name = name)
345        del_fn = get_name(self.del_proto)
346        out += """
347    if (self->o) {{
348        {del_fn}(self->o);
349    }}
350    Py_TYPE(self)->tp_free((PyObject *) self);
351}}
352""".format(del_fn = del_fn)
353        return out
354
355    def gen_do(self):
356        out = """
357// do {shortname}
358static PyObject*
359Py_{shortname}_do  (Py_{shortname} * self, PyObject * args)
360{{""".format(**self.__dict__)
361        input_params = self.do_inputs
362        output_params = self.do_outputs
363        #print input_params
364        #print output_params
365        for input_param in input_params:
366            out += """
367    PyObject *py_{0};""".format(input_param['name'])
368        refs = ", ".join(["&py_%s" % p['name'] for p in input_params])
369        pyparamtypes = "".join([pyargparse_chars[p['type']] for p in input_params])
370        out += """
371    if (!PyArg_ParseTuple (args, "{pyparamtypes}", {refs})) {{
372        return NULL;
373    }}""".format(refs = refs, pyparamtypes = pyparamtypes, **self.__dict__)
374        for input_param in input_params:
375            out += """
376
377    if (!{pytoaubio}(py_{0[name]}, &(self->{0[name]}))) {{
378        return NULL;
379    }}""".format(input_param, pytoaubio = pytoaubio_fn[input_param['type']])
380        out += """
381
382    // TODO: check input sizes"""
383        for output_param in output_params:
384            out += """
385
386    Py_INCREF(self->{0[name]});
387    if (!{pytoaubio}(self->{0[name]}, &(self->c_{0[name]}))) {{
388        return NULL;
389    }}""".format(output_param, pytoaubio = pytoaubio_fn[output_param['type']])
390        do_fn = get_name(self.do_proto)
391        inputs = ", ".join(['&(self->'+p['name']+')' for p in input_params])
392        c_outputs = ", ".join(["&(self->c_%s)" % p['name'] for p in self.do_outputs])
393        outputs = ", ".join(["self->%s" % p['name'] for p in self.do_outputs])
394        out += """
395
396    {do_fn}(self->o, {inputs}, {c_outputs});
397
398    return {outputs};
399}}
400""".format(
401        do_fn = do_fn,
402        inputs = inputs, outputs = outputs, c_outputs = c_outputs,
403        )
404        return out
405
406    def gen_set(self):
407        out = """
408// {shortname} setters
409""".format(**self.__dict__)
410        for set_param in self.prototypes['set']:
411            params = get_params_types_names(set_param)[1]
412            paramtype = params['type']
413            method_name = get_name(set_param)
414            param = method_name.split('aubio_'+self.shortname+'_set_')[-1]
415            pyparamtype = pyargparse_chars[paramtype]
416            out += """
417static PyObject *
418Pyaubio_{shortname}_set_{param} (Py_{shortname} *self, PyObject *args)
419{{
420  uint_t err = 0;
421  {paramtype} {param};
422
423  if (!PyArg_ParseTuple (args, "{pyparamtype}", &{param})) {{
424    return NULL;
425  }}
426  err = aubio_{shortname}_set_{param} (self->o, {param});
427
428  if (err > 0) {{
429    PyErr_SetString (PyExc_ValueError, "error running aubio_{shortname}_set_{param}");
430    return NULL;
431  }}
432  Py_RETURN_NONE;
433}}
434""".format(param = param, paramtype = paramtype, pyparamtype = pyparamtype, **self.__dict__)
435        return out
436
437    def gen_get(self):
438        out = """
439// {shortname} getters
440""".format(**self.__dict__)
441        for method in self.prototypes['get']:
442            params = get_params_types_names(method)
443            method_name = get_name(method)
444            assert len(params) == 1, \
445                "get method has more than one parameter %s" % params
446            param = method_name.split('aubio_'+self.shortname+'_get_')[-1]
447            paramtype = get_return_type(method)
448            ptypeconv = pyfromtype_fn[paramtype]
449            out += """
450static PyObject *
451Pyaubio_{shortname}_get_{param} (Py_{shortname} *self, PyObject *unused)
452{{
453  {ptype} {param} = aubio_{shortname}_get_{param} (self->o);
454  return (PyObject *){ptypeconv} ({param});
455}}
456""".format(param = param, ptype = paramtype, ptypeconv = ptypeconv,
457        **self.__dict__)
458        return out
459
460    def gen_methodef(self):
461        out = """
462static PyMethodDef Py_{shortname}_methods[] = {{""".format(**self.__dict__)
463        for m in self.prototypes['set']:
464            name = get_name(m)
465            shortname = name.replace('aubio_%s_' % self.shortname, '')
466            out += """
467  {{"{shortname}", (PyCFunction) Py{name},
468    METH_VARARGS, ""}},""".format(name = name, shortname = shortname)
469        for m in self.prototypes['get']:
470            name = get_name(m)
471            shortname = name.replace('aubio_%s_' % self.shortname, '')
472            out += """
473  {{"{shortname}", (PyCFunction) Py{name},
474    METH_NOARGS, ""}},""".format(name = name, shortname = shortname)
475        out += """
476  {NULL} /* sentinel */
477};
478"""
479        return out
480
481    def gen_typeobject(self):
482        return """
483PyTypeObject Py_{shortname}Type = {{
484  //PyObject_HEAD_INIT (NULL)
485  //0,
486  PyVarObject_HEAD_INIT (NULL, 0)
487  "aubio.{shortname}",
488  sizeof (Py_{shortname}),
489  0,
490  (destructor) Py_{shortname}_del,
491  0,
492  0,
493  0,
494  0,
495  0,
496  0,
497  0,
498  0,
499  0,
500  (ternaryfunc)Py_{shortname}_do,
501  0,
502  0,
503  0,
504  0,
505  Py_TPFLAGS_DEFAULT,
506  Py_{shortname}_doc,
507  0,
508  0,
509  0,
510  0,
511  0,
512  0,
513  Py_{shortname}_methods,
514  Py_{shortname}_members,
515  0,
516  0,
517  0,
518  0,
519  0,
520  0,
521  (initproc) Py_{shortname}_init,
522  0,
523  Py_{shortname}_new,
524  0,
525  0,
526  0,
527  0,
528  0,
529  0,
530  0,
531  0,
532  0,
533}};
534""".format(**self.__dict__)
Note: See TracBrowser for help on using the repository browser.