Changeset a7f398d for python/lib/gen_code.py

Timestamp:

Apr 21, 2016, 9:32:59 PM (9 years ago)

Author:

Paul Brossier <piem@piem.org>

Branches:

feature/autosink, feature/cnn, feature/cnn_org, feature/constantq, feature/crepe, feature/crepe_org, feature/pitchshift, feature/pydocstrings, feature/timestretch, fix/ffmpeg5, master, pitchshift, sampler, timestretch, yinfft+

Children:

e31aad20

Parents:

b5bef11

Message:

python/lib/gen_code.py: use new proxy functions

File:

• python/lib/gen_code.py (modified) (14 diffs)

python/lib/gen_code.py

@@ -39 +39 @@
         'fvec_t*': 'PyAubio_ArrayToCFvec',
         'cvec_t*': 'PyAubio_ArrayToCCvec',
-        'fmat_t*': 'PyAubio_ArrayToCFmat',
+        #'fmat_t*': 'PyAubio_ArrayToCFmat',
         }
 
@@ -75 +75 @@
         'fmat_t*': 'O',
         'fvec_t*': 'O',
+        'cvec_t*': 'O',
         }
 
@@ -84 +85 @@
         'mfcc': 'self->n_coeffs',
         'specdesc': '1',
-        'tempo': '1',
+        'tempo': '2',
         'filterbank': 'self->n_filters',
+        'tss': 'self->hop_size',
         }
 
@@ -105 +107 @@
         return ['foo*', 'name'] """
     l = arg.split()
-    type_arg = {'type': l[0], 'name': l[1]}
-    # ['foo', '*name'] -> ['foo*', 'name']
-    if l[-1].startswith('*'):
-        #return [l[0]+'*', l[1][1:]]
-        type_arg['type'] = l[0] + '*'
-        type_arg['name'] = l[1][1:]
-    # ['foo', '*', 'name'] -> ['foo*', 'name']
-    if len(l) == 3:
-        #return [l[0]+l[1], l[2]]
-        type_arg['type'] = l[0]+l[1]
-        type_arg['name'] = l[2]
-    else:
-        #return l
-        pass
+    type_arg = {} #'type': l[0], 'name': l[1]}
+    type_arg['type'] = " ".join(l[:-1])
+    type_arg['name'] = l[-1]
+    # fix up type / name
+    if type_arg['name'].startswith('*'):
+        # ['foo', '*name'] -> ['foo*', 'name']
+        type_arg['type'] += '*'
+        type_arg['name'] = type_arg['name'][1:]
+    if type_arg['type'].endswith(' *'):
+        # ['foo *', 'name'] -> ['foo*', 'name']
+        type_arg['type'] = type_arg['type'].replace(' *','*')
+    if type_arg['type'].startswith('const '):
+        # ['foo *', 'name'] -> ['foo*', 'name']
+        type_arg['type'] = type_arg['type'].replace('const ','')
     return type_arg
 
@@ -127 +129 @@
     """
     import re
-    paramregex = re.compile('[\(, ](\w+ \*?\*? ?\w+)[, \)]')
-    return paramregex.findall(proto)
+    paramregex = re.compile('.*\((.*)\);')
+    a = paramregex.findall(proto)[0].split(', ')
+    #a = [i.replace('const ', '') for i in a]
+    return a
+
+def get_input_params(proto):
+    a = get_params(proto)
+    return [i.replace('const ', '') for i in a if (i.startswith('const ') or i.startswith('uint_t ') or i.startswith('smpl_t '))]
+
+def get_output_params(proto):
+    a = get_params(proto)
+    return [i for i in a if not i.startswith('const ')][1:]
 
 def get_params_types_names(proto):
@@ -135 +147 @@
     returns: [['int', 'argc'], ['char **','argv']]
     """
-    return list(map(split_type, get_params(proto)))
-
+    a = list(map(split_type, get_params(proto)))
+    #print proto, a
+    #import sys; sys.exit(1)
+    return a
 
 class MappedObject(object):
@@ -149 +163 @@
         self.do_proto = prototypes['do'][0]
         self.input_params = get_params_types_names(self.new_proto)
-        self.input_params_list = "; ".join(get_params(self.new_proto))
+        self.input_params_list = "; ".join(get_input_params(self.new_proto))
         self.outputs = get_params_types_names(self.do_proto)[2:]
-        self.outputs_flat = get_params(self.do_proto)[2:]
-        self.output_results = ", ".join(self.outputs_flat)
+        self.do_inputs = [get_params_types_names(self.do_proto)[1]]
+        self.do_outputs = get_params_types_names(self.do_proto)[2:]
+        self.outputs_flat = get_output_params(self.do_proto)
+        self.output_results = "; ".join(self.outputs_flat)
+
+        print "input_params", map(split_type, get_input_params(self.do_proto))
+        print "output_params", map(split_type, get_output_params(self.do_proto))
 
     def gen_code(self):
@@ -178 +197 @@
     // input parameters
     {input_params_list};
+    // do input vectors
+    {do_inputs_list};
     // output results
     {output_results};
 }} Py_{shortname};
 """
-        return out.format(**self.__dict__)
+        return out.format(do_inputs_list = "; ".join(get_input_params(self.do_proto)), **self.__dict__)
 
     def gen_doc(self):
@@ -188 +209 @@
 // TODO: add documentation
 static char Py_{shortname}_doc[] = \"undefined\";
-    """
+"""
         return out.format(**self.__dict__)
 
@@ -222 +243 @@
         params = self.input_params
         for p in params:
-            out += self.check_valid(p) 
+            out += self.check_valid(p)
         out += """
     return (PyObject *)self;
@@ -290 +311 @@
   // TODO get internal params after actual object creation?
 """
+        for input_param in self.do_inputs:
+            out += """
+  self->{0} = ({1})malloc(sizeof({2}));""".format(input_param['name'], input_param['type'], input_param['type'][:-1])
         out += """
   // create outputs{output_create}
@@ -318 +342 @@
 Py_{shortname}_del  (Py_{shortname} * self, PyObject * unused)
 {{""".format(**self.__dict__)
+        for input_param in self.do_inputs:
+            out += """
+    free(self->{0[name]});""".format(input_param)
         for o in self.outputs:
             name = o['name']
@@ -332 +359 @@
 
     def gen_do(self):
-        do_fn = get_name(self.do_proto)
-        input_param = get_params_types_names(self.do_proto)[1];
-        pytoaubio = pytoaubio_fn[input_param['type']]
         output = self.outputs[0]
         out = """
@@ -340 +364 @@
 static PyObject*
 Py_{shortname}_do  (Py_{shortname} * self, PyObject * args)
-{{
-    PyObject * in_obj;
-    {input_type} {input_name};
-
-    if (!PyArg_ParseTuple (args, "O", &in_obj)) {{
+{{""".format(**self.__dict__)
+        input_params = self.do_inputs
+        output_params = self.do_outputs
+        #print input_params
+        #print output_params
+        for input_param in input_params:
+            out += """
+    PyObject *py_{0};""".format(input_param['name'], input_param['type'])
+        refs = ", ".join(["&py_%s" % p['name'] for p in input_params])
+        pyparamtypes = "".join([pyargparse_chars[p['type']] for p in input_params])
+        out += """
+    if (!PyArg_ParseTuple (args, "{pyparamtypes}", {refs})) {{
         return NULL;
-    }}
-    {input_name} = {pytoaubio} (in_obj); 
-    if ({input_name} == NULL) {{
+    }}""".format(refs = refs, pyparamtypes = pyparamtypes, **self.__dict__)
+        for p in input_params:
+            out += """
+    if (!{pytoaubio}(py_{0[name]}, self->{0[name]})) {{
         return NULL;
-    }}
-
-    {do_fn}(self->o, {input_name}, {outputs});
+    }}""".format(input_param, pytoaubio = pytoaubio_fn[input_param['type']])
+        do_fn = get_name(self.do_proto)
+        inputs = ", ".join(['self->'+p['name'] for p in input_params])
+        outputs = ", ".join(["self->%s" % p['name'] for p in self.do_outputs])
+        out += """
+
+    {do_fn}(self->o, {inputs}, {outputs});
 
     return (PyObject *) {aubiotonumpy} ({outputs});
 }}
-"""
-        return out.format(do_fn = do_fn,
-                shortname = self.prototypes['shortname'],
-                input_name = input_param['name'],
-                input_type= input_param['type'],
-                pytoaubio = pytoaubio,
-                outputs = ", ".join(["self->%s" % p['name'] for p in self.outputs]),
-                aubiotonumpy = pyfromaubio_fn[output['type']], 
-                )
+""".format(
+        do_fn = do_fn,
+        aubiotonumpy = pyfromaubio_fn[output['type']], 
+        inputs = inputs, outputs = outputs,
+        )
+        return out
 
     def gen_set(self):