Changeset f264b17 for python

python/README

-                      r60fc05b
+                      rf264b17
     $ export PYTHONPATH=$PYTHONPATH:$PWD/`ls -rtd build/lib.* | head -1`:$PWD/tests
-Similarly, you can use the aubio module without installing libaubio by pointing
-LD_LIBRARY_PATH to the path libaubio can be found at:
-    $ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:PWD/../build/src
-Or on Mac OS X systems, setting DYLD_LIBRARY_PATH:
-    $ export DYLD_LIBRARY_PATH=$DYLD_LIBRARY_PATH:$PWD/../build/src
 Testing the Python module
 -------------------------

python/demos/demo_bpm_extract.py

-                      r60fc05b
+                      rf264b17
 from numpy import median, diff
 def get_file_bpm(path, params = {}):
+def get_file_bpm(path, params = None):
     """ Calculate the beats per minute (bpm) of a given file.
         path: path to the file
         param: dictionary of parameters
     """
+    if params is None:
+        params = {}
     try:
         win_s = params['win_s']
         samplerate = params['samplerate']
         hop_s = params['hop_s']
     except:
+    except KeyError:
         """
         # super fast
 …
     # Convert to periods and to bpm
+    bpms = 60./diff(beats)
+    b = median(bpms)
+    if len(beats) > 1:
+        if len(beats) < 4:
+            print("few beats found in {:s}".format(path))
+        bpms = 60./diff(beats)
+        b = median(bpms)
+    else:
+        b = 0
+        print("not enough beats found in {:s}".format(path))
     return b
 …
     for f in sys.argv[1:]:
         bpm = get_file_bpm(f)
         print "%6s" % ("%.2f" % bpm), f
+        print("{:6s} {:s}".format("{:2f}".format(bpm), f))

python/demos/demo_filterbank.py

-                      r60fc05b
+                      rf264b17
 from aubio import filterbank, fvec
 from pylab import loglog, show, subplot, xlim, ylim, xlabel, ylabel, title
+from pylab import loglog, show, xlim, ylim, xlabel, ylabel, title
 from numpy import vstack, arange
 …
 f.set_coeffs(coeffs)
 times = vstack([arange(win_s / 2 + 1) * samplerate / win_s] * n_filters)
+times = vstack([arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)
 title('Bank of filters built using a simple list of boundaries\nThe middle band has been amplified by 2.')
 loglog(times.T, f.get_coeffs().T, '.-')

python/demos/demo_filterbank_slaney.py

-                      r60fc05b
+                      rf264b17
 from aubio import filterbank
 from numpy import array, arange, vstack
+from numpy import arange, vstack
 win_s = 8192
 …
 from pylab import loglog, title, show, xlim, ylim, xlabel, ylabel
 xlim([0,samplerate / 2])
 times = vstack([arange(win_s / 2 + 1) * samplerate / win_s] * 40)
+times = vstack([arange(win_s // 2 + 1) * samplerate / win_s] * 40)
 loglog(times.T, f.get_coeffs().T, '.-')
 title('Mel frequency bands coefficients')

python/demos/demo_filterbank_triangle_bands.py

-                      r60fc05b
+                      rf264b17
 subplot(211)
 title('Examples of filterbank built with set_triangle_bands and set_coeffs')
 times = vstack([arange(win_s / 2 + 1) * samplerate / win_s] * n_filters)
+times = vstack([arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)
 loglog(times.T, f.get_coeffs().T, '.-')
 xlim([50, samplerate/2])
 …
 subplot(212)
 times = vstack([arange(win_s / 2 + 1) * samplerate / win_s] * n_filters)
+times = vstack([arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)
 loglog(times.T, f.get_coeffs().T, '.-')
 xlim([50, samplerate/2])

python/demos/demo_keyboard.py

r60fc05b	rf264b17
26	26
27	27	def create_keyboard_patches(firstnote, lastnote, ax = None):
28		~~import numpy as np~~
29	28	import matplotlib.pyplot as plt
30	29	from matplotlib.path import Path

python/demos/demo_mel-energy.py

-                      r60fc05b
+                      rf264b17
 import sys
 from aubio import fvec, source, pvoc, filterbank
+from aubio import source, pvoc, filterbank
 from numpy import vstack, zeros
 win_s = 512                 # fft size
 hop_s = win_s / 4           # hop size
+hop_s = win_s // 4          # hop size
 if len(sys.argv) < 2:
     print "Usage: %s <filename> [samplerate]" % sys.argv[0]
+    print("Usage: %s <filename> [samplerate]" % sys.argv[0])
     sys.exit(1)
 …
     fftgrain = pv(samples)
     new_energies = f(fftgrain)
     print '%f' % (total_frames / float(samplerate) ),
     print ' '.join(['%f' % b for b in new_energies])
+    timestr = '%f' % (total_frames / float(samplerate) )
+    print('{:s} {:s}'.format(timestr, ' '.join(['%f' % b for b in new_energies])))
     energies = vstack( [energies, new_energies] )
     total_frames += read
 …
 if 1:
     print "done computing, now plotting"
+    print("done computing, now plotting")
     import matplotlib.pyplot as plt
     from demo_waveform_plot import get_waveform_plot

python/demos/demo_mfcc.py

-                      r60fc05b
+                      rf264b17
 import sys
 from aubio import source, pvoc, mfcc
 from numpy import array, vstack, zeros
+from numpy import vstack, zeros
 win_s = 512                 # fft size
 hop_s = win_s / 4           # hop size
+hop_s = win_s // 4          # hop size
 n_filters = 40              # must be 40 for mfcc
 n_coeffs = 13
 …
 if len(sys.argv) < 2:
     print "Usage: %s <source_filename>" % sys.argv[0]
+    print("Usage: %s <source_filename>" % sys.argv[0])
     sys.exit(1)

python/demos/demo_onset.py

-                      r60fc05b
+                      rf264b17
 win_s = 512                 # fft size
 hop_s = win_s / 2           # hop size
+hop_s = win_s // 2          # hop size
 if len(sys.argv) < 2:
     print "Usage: %s <filename> [samplerate]" % sys.argv[0]
+    print("Usage: %s <filename> [samplerate]" % sys.argv[0])
     sys.exit(1)
 …
     samples, read = s()
     if o(samples):
         print "%f" % o.get_last_s()
+        print("%f" % o.get_last_s())
         onsets.append(o.get_last())
     total_frames += read

python/demos/demo_onset_plot.py

-                      r60fc05b
+                      rf264b17
 import sys
 from aubio import onset, source
 from numpy import array, hstack, zeros
+from numpy import hstack, zeros
 win_s = 512                 # fft size
 hop_s = win_s / 2           # hop size
+hop_s = win_s // 2          # hop size
 if len(sys.argv) < 2:
     print "Usage: %s <filename> [samplerate]" % sys.argv[0]
+    print("Usage: %s <filename> [samplerate]" % sys.argv[0])
     sys.exit(1)
 …
     samples, read = s()
     if o(samples):
         print "%f" % (o.get_last_s())
+        print("%f" % (o.get_last_s()))
         onsets.append(o.get_last())
     # keep some data to plot it later
     new_maxes = (abs(samples.reshape(hop_s/downsample, downsample))).max(axis=0)
+    new_maxes = (abs(samples.reshape(hop_s//downsample, downsample))).max(axis=0)
     allsamples_max = hstack([allsamples_max, new_maxes])
     desc.append(o.get_descriptor())
 …
 if 1:
     # do plotting
-    from numpy import arange
     import matplotlib.pyplot as plt
     allsamples_max = (allsamples_max > 0) * allsamples_max
 …
     plt1.yaxis.set_visible(False)
     desc_times = [ float(t) * hop_s / samplerate for t in range(len(desc)) ]
+    desc_plot = [d / max(desc) for d in desc]
+    desc_max = max(desc) if max(desc) != 0 else 1.
+    desc_plot = [d / desc_max for d in desc]
     plt2.plot(desc_times, desc_plot, '-g')
     tdesc_plot = [d / max(desc) for d in tdesc]
+    tdesc_plot = [d / desc_max for d in tdesc]
     for stamp in onsets:
         stamp /= float(samplerate)

python/demos/demo_pitch.py

-                      r60fc05b
+                      rf264b17
 import sys
 from aubio import source, pitch, freqtomidi
+from aubio import source, pitch
 if len(sys.argv) < 2:
     print "Usage: %s <filename> [samplerate]" % sys.argv[0]
+    print("Usage: %s <filename> [samplerate]" % sys.argv[0])
     sys.exit(1)
 …
 downsample = 1
 samplerate = 44100 / downsample
+samplerate = 44100 // downsample
 if len( sys.argv ) > 2: samplerate = int(sys.argv[2])
 win_s = 4096 / downsample # fft size
 hop_s = 512  / downsample # hop size
+win_s = 4096 // downsample # fft size
+hop_s = 512  // downsample # hop size
 s = source(filename, samplerate, hop_s)
 …
     confidence = pitch_o.get_confidence()
     #if confidence < 0.8: pitch = 0.
     #print "%f %f %f" % (total_frames / float(samplerate), pitch, confidence)
+    print("%f %f %f" % (total_frames / float(samplerate), pitch, confidence))
     pitches += [pitch]
     confidences += [confidence]
 …
 #print pitches
+import os.path
 from numpy import array, ma
 import matplotlib.pyplot as plt
 …
 def array_from_text_file(filename, dtype = 'float'):
-    import os.path
-    from numpy import array
     filename = os.path.join(os.path.dirname(__file__), filename)
     return array([line.split() for line in open(filename).readlines()],
 …
 ax2 = fig.add_subplot(312, sharex = ax1)
-import sys, os.path
 ground_truth = os.path.splitext(filename)[0] + '.f0.Corrected'
 if os.path.isfile(ground_truth):

python/demos/demo_pitch_sinusoid.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy import random, sin, arange, ones, zeros
+from math import pi
+from aubio import fvec, pitch
+import numpy as np
+import aubio
 def build_sinusoid(length, freqs, samplerate):
   return sin( 2. * pi * arange(length) * freqs / samplerate)
+    return np.sin( 2. * np.pi * np.arange(length) * freqs / samplerate).astype(aubio.float_type)
 def run_pitch(p, input_vec):
+  f = fvec (p.hop_size)
+  cands = []
+  count = 0
+  for vec_slice in input_vec.reshape((-1, p.hop_size)):
+    f[:] = vec_slice
+    cands.append(p(f))
+  return cands
+    cands = []
+    for vec_slice in input_vec.reshape((-1, p.hop_size)):
+        a = p(vec_slice)[0]
+        cands.append(a)
+    return cands
 methods = ['default', 'schmitt', 'fcomb', 'mcomb', 'yin', 'yinfft']
 …
 samplerate = 44100
 sin_length = (samplerate * 10) % 512 * 512
 freqs = zeros(sin_length)
+freqs = np.zeros(sin_length)
 partition = sin_length / 8
+partition = sin_length // 8
 pointer = 0
 …
 pointer += partition
 pointer += partition
 freqs[ pointer : pointer + partition ] = 400 + 5 * random.random(sin_length/8)
+freqs[ pointer : pointer + partition ] = 400 + 5 * np.random.random(sin_length/8)
 a = build_sinusoid(sin_length, freqs, samplerate)
 for method in methods:
+  p = pitch(method, buf_size, hop_size, samplerate)
+  cands[method] = run_pitch(p, a)
+    p = aubio.pitch(method, buf_size, hop_size, samplerate)
+    cands[method] = run_pitch(p, a)
+    print(method)
+    print(cands[method])
 print "done computing"
+print("done computing")
 if 1:
+  from pylab import plot, show, xlabel, ylabel, legend, ylim
+  ramp = arange(0, sin_length / hop_size).astype('float') * hop_size / samplerate
+  for method in methods:
+    plot(ramp, cands[method],'.-')
+    import matplotlib.pyplot as plt
+  # plot ground truth
+  ramp = arange(0, sin_length).astype('float') / samplerate
+  plot(ramp, freqs, ':')
+    # times
+    ramp = np.arange(0, sin_length / hop_size).astype('float') * hop_size / samplerate
+  legend(methods+['ground truth'], 'upper right')
+  xlabel('time (s)')
+  ylabel('frequency (Hz)')
+  ylim([0,2000])
+  show()
+    # plot each result
+    for method in methods:
+        plt.plot(ramp, cands[method], '.-', label=method)
+    # plot ground truth
+    ramp = np.arange(0, sin_length).astype('float') / samplerate
+    plt.plot(ramp, freqs, ':', label = 'ground truth')
+    plt.legend(loc='upper left')
+    plt.xlabel('time (s)')
+    plt.ylabel('frequency (Hz)')
+    plt.ylim([0,2000])
+    plt.show()

python/demos/demo_pysoundcard_play.py

r60fc05b	rf264b17
11	11	samplerate = f.samplerate
12	12
13		s = Stream(sample~~_rate = samplerate, block_length~~ = hop_size)
	13	s = Stream(samplerate = samplerate, blocksize = hop_size)
14	14	s.start()
15	15	read = 0

python/demos/demo_pysoundcard_record.py

-                      r60fc05b
+                      rf264b17
     hop_size = 256
     duration = 5 # in seconds
     s = Stream(block_length = hop_size)
     g = sink(sink_path, samplerate = s.sample_rate)
+    s = Stream(blocksize = hop_size, channels = 1)
+    g = sink(sink_path, samplerate = int(s.samplerate))
     s.start()
     total_frames = 0
+    while total_frames < duration * s.sample_rate:
+        vec = s.read(hop_size)
+        # mix down to mono
+        mono_vec = vec.sum(-1) / float(s.input_channels)
+        g(mono_vec, hop_size)
+        total_frames += hop_size
+    try:
+        while total_frames < duration * s.samplerate:
+            vec = s.read(hop_size)
+            # mix down to mono
+            mono_vec = vec.sum(-1) / float(s.channels[0])
+            g(mono_vec, hop_size)
+            total_frames += hop_size
+    except KeyboardInterrupt:
+        duration = total_frames / float(s.samplerate)
+        print("stopped after %.2f seconds" % duration)
     s.stop()

python/demos/demo_simple_robot_voice.py

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
   if len(sys.argv) < 2:
     print 'usage: %s <inputfile> <outputfile>' % sys.argv[0]
     sys.exit(1)
   samplerate = 44100
   f = source(sys.argv[1], samplerate, 256)
   g = sink(sys.argv[2], samplerate)
   total_frames, read = 0, 256
+    if len(sys.argv) < 2:
+        print('usage: %s <inputfile> <outputfile>' % sys.argv[0])
+        sys.exit(1)
+    samplerate = 44100
+    f = source(sys.argv[1], samplerate, 256)
+    g = sink(sys.argv[2], samplerate)
+    total_frames, read = 0, 256
   win_s = 512                 # fft size
   hop_s = win_s / 2           # hop size
   pv = pvoc(win_s, hop_s)                            # phase vocoder
+    win_s = 512                          # fft size
+    hop_s = win_s // 2                   # hop size
+    pv = pvoc(win_s, hop_s)              # phase vocoder
   while read:
     samples, read = f()
     spectrum = pv(samples)            # compute spectrum
     #spectrum.norm *= .8               # reduce amplitude a bit
     spectrum.phas[:] = 0.             # zero phase
     new_samples = pv.rdo(spectrum)    # compute modified samples
     g(new_samples, read)              # write to output
     total_frames += read
+    while read:
+        samples, read = f()
+        spectrum = pv(samples)           # compute spectrum
+        #spectrum.norm *= .8             # reduce amplitude a bit
+        spectrum.phas[:] = 0.            # zero phase
+        new_samples = pv.rdo(spectrum)   # compute modified samples
+        g(new_samples, read)             # write to output
+        total_frames += read
+  print "wrote", total_frames, "from", f.uri, "to", g.uri
+    format_str = "read {:d} samples from {:s}, written to {:s}"
+    print(format_str.format(total_frames, f.uri, g.uri))

python/demos/demo_simple_spectral_weighting.py

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
     if len(sys.argv) < 2:
         print 'usage: %s <inputfile> <outputfile>' % sys.argv[0]
+        print('usage: %s <inputfile> <outputfile>' % sys.argv[0])
         sys.exit(1)
     samplerate = 0
 …
     win_s = 512 # fft size
     hop_s = win_s / 2 # hop size
+    hop_s = win_s // 2 # hop size
     pv = pvoc(win_s, hop_s) # phase vocoder
 …
         zeros( 50 ),
 .3 * hanningz(100),
         zeros (win_s / 2 + 1 - 40 - 50 - 100),
+        zeros (win_s // 2 + 1 - 40 - 50 - 100),
         ] )
 …
         total_frames += read
+    print "read", total_frames / float(samplerate), "seconds from", f.uri
+    duration = total_frames / float(samplerate)
+    print("read {:.3f}s from {:s}".format(duration, f.uri))

python/demos/demo_sink.py

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
     if len(sys.argv) < 3:
         print 'usage: %s <inputfile> <outputfile> [samplerate] [hop_size]' % sys.argv[0]
+        print('usage: %s <inputfile> <outputfile> [samplerate] [hop_size]' % sys.argv[0])
         sys.exit(1)
 …
         g(vec, read)
         total_frames += read
+    print "wrote", "%.2fs" % (total_frames / float(samplerate) ),
+    print "(", total_frames, "frames", "in",
+    print total_frames / f.hop_size, "blocks", "at", "%dHz" % f.samplerate, ")",
+    print "from", f.uri,
+    print "to", g.uri
+    outstr = "wrote %.2fs" % (total_frames / float(samplerate))
+    outstr += " (%d frames in" % total_frames
+    outstr += " %d blocks" % (total_frames // f.hop_size)
+    outstr += " at %dHz)" % f.samplerate
+    outstr += " from " + f.uri
+    outstr += " to " + g.uri
+    print(outstr)

python/demos/demo_sink_create_woodblock.py

-                      r60fc05b
+                      rf264b17
 import sys
 from math import pi, e
 from aubio import sink
 from numpy import arange, resize, sin, exp, zeros
+from aubio import sink, float_type
+from numpy import arange, sin, exp, zeros
 if len(sys.argv) < 2:
     print 'usage: %s <outputfile> [samplerate]' % sys.argv[0]
+    print('usage: %s <outputfile> [samplerate]' % sys.argv[0])
     sys.exit(1)
 …
 # create a sine lookup table
 tablelen = 1000
 sinetable = arange(tablelen + 1, dtype = 'float32')
+sinetable = arange(tablelen + 1, dtype = float_type)
 sinetable = 0.7 * sin(twopi * sinetable/tablelen)
 sinetone = zeros((duration,), dtype = 'float32')
+sinetone = zeros((duration,), dtype = float_type)
 # compute sinetone at floating point period
 …
 # apply some envelope
 float_ramp = arange(duration, dtype = 'float32')
+float_ramp = arange(duration, dtype = float_type)
 sinetone *= exp( - e * float_ramp / duration / decay)
 sinetone[:attack] *= exp( e * ( float_ramp[:attack] / attack - 1 ) )

python/demos/demo_sink_multi.py

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
     if len(sys.argv) < 3:
         print 'usage: %s <inputfile> <outputfile> [samplerate] [hop_size]' % sys.argv[0]
+        print('usage: %s <inputfile> <outputfile> [samplerate] [hop_size]' % sys.argv[0])
         sys.exit(1)
 …
         g.do_multi(vec, read)
         total_frames += read
+    print "wrote", "%.2fs" % (total_frames / float(samplerate) ),
+    print "(", total_frames, "frames", "in",
+    print total_frames / f.hop_size, "blocks",
+    print "of", f.channels, "channels",
+    print "at", "%dHz" % f.samplerate, ")",
+    print "from", f.uri,
+    print "to", g.uri
+    outstr = "wrote %.2fs" % (total_frames / float(samplerate))
+    outstr += " (%d frames in" % total_frames
+    outstr += " %d blocks" % (total_frames // f.hop_size)
+    outstr += " of %d channels" % f.channels
+    outstr += " at %dHz)" % f.samplerate
+    outstr += " from " + f.uri
+    outstr += " to " + g.uri
+    print(outstr)

python/demos/demo_slicing.py

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
     if len(sys.argv) < 3:
         print 'usage: %s <inputfile> <duration>' % sys.argv[0]
+        print('usage: %s <inputfile> <duration>' % sys.argv[0])
         sys.exit(1)
     source_file = sys.argv[1]
 …
     total_duration = total_frames_written / float(samplerate)
     slice_n += 1
+    print 'created %(slice_n)s slices from %(source_base_name)s%(source_ext)s' % locals(),
+    print ' (total duration %(total_duration).2fs)' % locals()
+    outstr = 'created %(slice_n)s slices from %(source_base_name)s%(source_ext)s' % locals()
+    outstr += ' (total duration %(total_duration).2fs)' % locals()
+    print(outstr)
     # close source and sink files
     del f, g

python/demos/demo_source.py

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
     if len(sys.argv) < 2:
         print 'usage: %s <inputfile> [samplerate] [hop_size]' % sys.argv[0]
+        print('usage: %s <inputfile> [samplerate] [hop_size]' % sys.argv[0])
         sys.exit(1)
     samplerate = 0
 …
         total_frames += read
         if read < f.hop_size: break
+    print "read", "%.2fs" % (total_frames / float(samplerate) ),
+    print "(", total_frames, "frames", "in",
+    print total_frames / f.hop_size, "blocks", "at", "%dHz" % f.samplerate, ")",
+    print "from", f.uri
+    outstr = "read %.2fs" % (total_frames / float(samplerate))
+    outstr += " (%d frames in" % total_frames
+    outstr += " %d blocks" % (total_frames // f.hop_size)
+    outstr += " at %dHz)" % f.samplerate
+    outstr += " from " + f.uri
+    print(outstr)

python/demos/demo_specdesc.py

-                      r60fc05b
+                      rf264b17
 import sys
+from aubio import fvec, source, pvoc, specdesc
 from numpy import hstack
+import numpy as np
+from aubio import source, pvoc, specdesc
 win_s = 512                 # fft size
 hop_s = win_s / 4           # hop size
+hop_s = win_s // 4          # hop size
 if len(sys.argv) < 2:
     print "Usage: %s <filename> [samplerate]" % sys.argv[0]
+    print("Usage: %s <filename> [samplerate]" % sys.argv[0])
     sys.exit(1)
 …
 for method in methods:
     cands = []
     all_descs[method] = fvec(0)
+    all_descs[method] = np.array([])
     o[method] = specdesc(method, win_s)
 …
     samples, read = s()
     fftgrain = pv(samples)
     #print "%f" % ( total_frames / float(samplerate) ),
+    #outstr = "%f" % ( total_frames / float(samplerate) )
     for method in methods:
         specdesc_val = o[method](fftgrain)[0]
         all_descs[method] = hstack ( [all_descs[method], specdesc_val] )
         #print "%f" % specdesc_val,
     #print
+        all_descs[method] = np.append(all_descs[method], specdesc_val)
+        #outstr += " %f" % specdesc_val
+    #print(outstr)
     total_frames += read
     if read < hop_s: break
 if 1:
     print "done computing, now plotting"
+    print("done computing, now plotting")
     import matplotlib.pyplot as plt
     from demo_waveform_plot import get_waveform_plot

python/demos/demo_spectrogram.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
 import sys
 from aubio import pvoc, source
 from numpy import array, arange, zeros, shape, log10, vstack
+from pylab import imshow, show, cm, axis, ylabel, xlabel, xticks, yticks
+import sys, os.path
+from aubio import pvoc, source, float_type
+from numpy import zeros, log10, vstack
+import matplotlib.pyplot as plt
 def get_spectrogram(filename, samplerate = 0):
   win_s = 512                                        # fft window size
   hop_s = win_s / 2                                  # hop size
   fft_s = win_s / 2 + 1                              # spectrum bins
+    win_s = 512                                        # fft window size
+    hop_s = win_s // 2                                 # hop size
+    fft_s = win_s // 2 + 1                             # spectrum bins
   a = source(filename, samplerate, hop_s)            # source file
   if samplerate == 0: samplerate = a.samplerate
   pv = pvoc(win_s, hop_s)                            # phase vocoder
   specgram = zeros([0, fft_s], dtype='float32')      # numpy array to store spectrogram
+    a = source(filename, samplerate, hop_s)            # source file
+    if samplerate == 0: samplerate = a.samplerate
+    pv = pvoc(win_s, hop_s)                            # phase vocoder
+    specgram = zeros([0, fft_s], dtype=float_type)     # numpy array to store spectrogram
   # analysis
   while True:
     samples, read = a()                              # read file
     specgram = vstack((specgram,pv(samples).norm))   # store new norm vector
     if read < a.hop_size: break
+    # analysis
+    while True:
+        samples, read = a()                              # read file
+        specgram = vstack((specgram,pv(samples).norm))   # store new norm vector
+        if read < a.hop_size: break
+  # plotting
+  imshow(log10(specgram.T + .001), origin = 'bottom', aspect = 'auto', cmap=cm.gray_r)
+  axis([0, len(specgram), 0, len(specgram[0])])
+  # show axes in Hz and seconds
+  time_step = hop_s / float(samplerate)
+  total_time = len(specgram) * time_step
+  print "total time: %0.2fs" % total_time,
+  print ", samplerate: %.2fkHz" % (samplerate / 1000.)
+  n_xticks = 10
+  n_yticks = 10
+    # plotting
+    fig = plt.imshow(log10(specgram.T + .001), origin = 'bottom', aspect = 'auto', cmap=plt.cm.gray_r)
+    ax = fig.axes
+    ax.axis([0, len(specgram), 0, len(specgram[0])])
+    # show axes in Hz and seconds
+    time_step = hop_s / float(samplerate)
+    total_time = len(specgram) * time_step
+    outstr = "total time: %0.2fs" % total_time
+    print(outstr + ", samplerate: %.2fkHz" % (samplerate / 1000.))
+    n_xticks = 10
+    n_yticks = 10
+  def get_rounded_ticks( top_pos, step, n_ticks ):
+      top_label = top_pos * step
+      # get the first label
+      ticks_first_label = top_pos * step / n_ticks
+      # round to the closest .1
+      ticks_first_label = round ( ticks_first_label * 10. ) / 10.
+      # compute all labels from the first rounded one
+      ticks_labels = [ ticks_first_label * n for n in range(n_ticks) ] + [ top_label ]
+      # get the corresponding positions
+      ticks_positions = [ ticks_labels[n] / step for n in range(n_ticks) ] + [ top_pos ]
+      # convert to string
+      ticks_labels = [  "%.1f" % x for x in ticks_labels ]
+      # return position, label tuple to use with x/yticks
+      return ticks_positions, ticks_labels
+  # apply to the axis
+  xticks( *get_rounded_ticks ( len(specgram), time_step, n_xticks ) )
+  yticks( *get_rounded_ticks ( len(specgram[0]), (samplerate / 2. / 1000.) / len(specgram[0]), n_yticks ) )
+  ylabel('Frequency (kHz)')
+  xlabel('Time (s)')
+    def get_rounded_ticks( top_pos, step, n_ticks ):
+        top_label = top_pos * step
+        # get the first label
+        ticks_first_label = top_pos * step / n_ticks
+        # round to the closest .1
+        ticks_first_label = round ( ticks_first_label * 10. ) / 10.
+        # compute all labels from the first rounded one
+        ticks_labels = [ ticks_first_label * n for n in range(n_ticks) ] + [ top_label ]
+        # get the corresponding positions
+        ticks_positions = [ ticks_labels[n] / step for n in range(n_ticks) ] + [ top_pos ]
+        # convert to string
+        ticks_labels = [  "%.1f" % x for x in ticks_labels ]
+        # return position, label tuple to use with x/yticks
+        return ticks_positions, ticks_labels
+    # apply to the axis
+    x_ticks, x_labels = get_rounded_ticks ( len(specgram), time_step, n_xticks )
+    y_ticks, y_labels = get_rounded_ticks ( len(specgram[0]), (samplerate / 1000. / 2.) / len(specgram[0]), n_yticks )
+    ax.set_xticks( x_ticks )
+    ax.set_yticks ( y_ticks )
+    ax.set_xticklabels( x_labels )
+    ax.set_yticklabels ( y_labels )
+    ax.set_ylabel('Frequency (kHz)')
+    ax.set_xlabel('Time (s)')
+    ax.set_title(os.path.basename(filename))
+    for item in ([ax.title, ax.xaxis.label, ax.yaxis.label] +
+            ax.get_xticklabels() + ax.get_yticklabels()):
+        item.set_fontsize('x-small')
+    return fig
 if __name__ == '__main__':
+  if len(sys.argv) < 2:
+    print "Usage: %s <filename>" % sys.argv[0]
+  else:
+    for soundfile in sys.argv[1:]:
+      get_spectrogram(soundfile)
+      # display graph
+      show()
+    if len(sys.argv) < 2:
+        print("Usage: %s <filename>" % sys.argv[0])
+    else:
+        for soundfile in sys.argv[1:]:
+            fig = get_spectrogram(soundfile)
+            # display graph
+            plt.show()
+            #outimage = os.path.basename(soundfile) + '.png'
+            #print ("writing: " + outimage)
+            #plt.savefig(outimage)
+            plt.close()

python/demos/demo_tempo.py

-                      r60fc05b
+                      rf264b17
 win_s = 512                 # fft size
 hop_s = win_s / 2           # hop size
+hop_s = win_s // 2          # hop size
 if len(sys.argv) < 2:
     print "Usage: %s <filename> [samplerate]" % sys.argv[0]
+    print("Usage: %s <filename> [samplerate]" % sys.argv[0])
     sys.exit(1)
 …
     if is_beat:
         this_beat = int(total_frames - delay + is_beat[0] * hop_s)
         print "%f" % (this_beat / float(samplerate))
+        print("%f" % (this_beat / float(samplerate)))
         beats.append(this_beat)
     total_frames += read

python/demos/demo_tempo_plot.py

-                      r60fc05b
+                      rf264b17
 win_s = 512                 # fft size
 hop_s = win_s / 2           # hop size
+hop_s = win_s // 2          # hop size
 if len(sys.argv) < 2:
     print "Usage: %s <filename> [samplerate]" % sys.argv[0]
+    print("Usage: %s <filename> [samplerate]" % sys.argv[0])
     sys.exit(1)
 …
 if len(beats) > 1:
     # do plotting
     from numpy import array, arange, mean, median, diff
+    from numpy import mean, median, diff
     import matplotlib.pyplot as plt
     bpms = 60./ diff(beats)
     print 'mean period:', "%.2f" % mean(bpms), 'bpm', 'median', "%.2f" % median(bpms), 'bpm'
     print 'plotting', filename
+    print('mean period: %.2fbpm, median: %.2fbpm' % (mean(bpms), median(bpms)))
+    print('plotting %s' % filename)
     plt1 = plt.axes([0.1, 0.75, 0.8, 0.19])
     plt2 = plt.axes([0.1, 0.1, 0.8, 0.65], sharex = plt1)
 …
 else:
     print 'mean period:', "%.2f" % 0, 'bpm', 'median', "%.2f" % 0, 'bpm',
     print 'nothing to plot, file too short?'
+    print('mean period: %.2fbpm, median: %.2fbpm' % (0, 0))
+    print('plotting %s' % filename)

python/demos/demo_tss.py

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
   if len(sys.argv) < 2:
     print 'usage: %s <inputfile> <outputfile_transient> <outputfile_steady>' % sys.argv[0]
     sys.exit(1)
+    if len(sys.argv) < 2:
+        print('usage: %s <inputfile> <outputfile_transient> <outputfile_steady>' % sys.argv[0])
+        sys.exit(1)
   samplerate = 44100
   win_s = 1024      # fft size
   hop_s = win_s / 4 # block size
   threshold = 0.5
+    samplerate = 44100
+    win_s = 1024       # fft size
+    hop_s = win_s // 4 # block size
+    threshold = 0.5
   f = source(sys.argv[1], samplerate, hop_s)
   g = sink(sys.argv[2], samplerate)
   h = sink(sys.argv[3], samplerate)
+    f = source(sys.argv[1], samplerate, hop_s)
+    g = sink(sys.argv[2], samplerate)
+    h = sink(sys.argv[3], samplerate)
   pva = pvoc(win_s, hop_s)    # a phase vocoder
   pvb = pvoc(win_s, hop_s)    # another phase vocoder
   t = tss(win_s, hop_s)       # transient steady state separation
+    pva = pvoc(win_s, hop_s)    # a phase vocoder
+    pvb = pvoc(win_s, hop_s)    # another phase vocoder
+    t = tss(win_s, hop_s)       # transient steady state separation
   t.set_threshold(threshold)
+    t.set_threshold(threshold)
   read = hop_s
+    read = hop_s
   while read:
     samples, read = f()               # read file
     spec = pva(samples)                # compute spectrum
     trans_spec, stead_spec = t(spec)  # transient steady-state separation
     transients = pva.rdo(trans_spec)   # overlap-add synthesis of transients
     steadstate = pvb.rdo(stead_spec)   # overlap-add synthesis of steady states
     g(transients, read)               # write transients to output
     h(steadstate, read)               # write steady states to output
+    while read:
+        samples, read = f()               # read file
+        spec = pva(samples)               # compute spectrum
+        trans_spec, stead_spec = t(spec)  # transient steady-state separation
+        transients = pva.rdo(trans_spec)  # overlap-add synthesis of transients
+        steadstate = pvb.rdo(stead_spec)  # overlap-add synthesis of steady states
+        g(transients, read)               # write transients to output
+        h(steadstate, read)               # write steady states to output
   del f, g, h                         # finish writing the files now
+    del f, g, h                           # finish writing the files now
   from demo_spectrogram import get_spectrogram
   from pylab import subplot, show
   subplot(311)
   get_spectrogram(sys.argv[1])
   subplot(312)
   get_spectrogram(sys.argv[2])
   subplot(313)
   get_spectrogram(sys.argv[3])
   show()
+    from demo_spectrogram import get_spectrogram
+    from pylab import subplot, show
+    subplot(311)
+    get_spectrogram(sys.argv[1])
+    subplot(312)
+    get_spectrogram(sys.argv[2])
+    subplot(313)
+    get_spectrogram(sys.argv[3])
+    show()

python/demos/demo_waveform_plot.py

-                      r60fc05b
+                      rf264b17
 import sys
 from aubio import pvoc, source
+from aubio import source
 from numpy import zeros, hstack
 …
         samples, read = a()
         # keep some data to plot it later
         new_maxes = (abs(samples.reshape(hop_s/downsample, downsample))).max(axis=0)
+        new_maxes = (abs(samples.reshape(hop_s//downsample, downsample))).max(axis=0)
         allsamples_max = hstack([allsamples_max, new_maxes])
         total_frames += read
 …
     import matplotlib.pyplot as plt
     if len(sys.argv) < 2:
         print "Usage: %s <filename>" % sys.argv[0]
+        print("Usage: %s <filename>" % sys.argv[0])
     else:
         for soundfile in sys.argv[1:]:

python/ext/aubio-types.h

-                      r60fc05b
+                      rf264b17
 #include <Python.h>
 #include <structmember.h>
+#include "aubio-generated.h"
 #define NPY_NO_DEPRECATED_API NPY_1_7_API_VERSION
 …
 #if HAVE_AUBIO_DOUBLE
+#error "Ouch! Python interface for aubio has not been much tested yet."
+// 64 bit precision with HAVE_AUBIO_DOUBLE=1
 #define AUBIO_NPY_SMPL NPY_DOUBLE
+#define AUBIO_NPY_SMPL_STR "float64"
+#define AUBIO_NPY_SMPL_CHR "d"
 #else
+// default is 32 bit precision
 #define AUBIO_NPY_SMPL NPY_FLOAT
+#define AUBIO_NPY_SMPL_STR "float32"
+#define AUBIO_NPY_SMPL_CHR "f"
 #endif
+// special python type for cvec
+typedef struct
+{
+  PyObject_HEAD
+  cvec_t * o;
+  uint_t length;
+  uint_t channels;
+} Py_cvec;
+// compat with Python < 2.6
+#ifndef Py_TYPE
+#define Py_TYPE(ob) (((PyObject*)(ob))->ob_type)
+#endif
 extern PyTypeObject Py_cvecType;
+PyObject * new_py_fvec(uint_t length);
+PyObject * new_py_cvec(uint_t length);
+PyObject * new_py_fmat(uint_t height, uint_t length);
 // defined in aubio-proxy.c
+extern int PyAubio_IsValidVector (PyObject *input);
 extern PyObject *PyAubio_CFvecToArray (fvec_t * self);
 extern fvec_t *PyAubio_ArrayToCFvec (PyObject * self);
+extern int PyAubio_ArrayToCFvec (PyObject * self, fvec_t *out);
+extern Py_cvec *PyAubio_CCvecToPyCvec (cvec_t * self);
+extern cvec_t *PyAubio_ArrayToCCvec (PyObject *input);
+extern int PyAubio_PyCvecToCCvec (PyObject *input, cvec_t *i);
 extern PyObject *PyAubio_CFmatToArray (fmat_t * self);
 extern fmat_t *PyAubio_ArrayToCFmat (PyObject *input);
+extern int PyAubio_ArrayToCFmat (PyObject *input, fmat_t *out);
 // hand written wrappers

python/ext/aubiomodule.c

-                      r60fc05b
+                      rf264b17
 #define PY_AUBIO_MODULE_MAIN
 #include "aubio-types.h"
-#include "aubio-generated.h"
 #include "py-musicutils.h"
 …
+{
   PyObject *input;
   fvec_t *vec;
+  fvec_t vec;
   smpl_t alpha;
   PyObject *result;
   if (!PyArg_ParseTuple (args, "Of:alpha_norm", &input, &alpha)) {
+  if (!PyArg_ParseTuple (args, "O" AUBIO_NPY_SMPL_CHR ":alpha_norm", &input, &alpha)) {
     return NULL;
+  }
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
     return NULL;
+  }
   // compute the function
   result = Py_BuildValue ("f", fvec_alpha_norm (vec, alpha));
+  result = Py_BuildValue (AUBIO_NPY_SMPL_CHR, fvec_alpha_norm (&vec, alpha));
   if (result == NULL) {
     return NULL;
 …
   smpl_t output;
   if (!PyArg_ParseTuple (args, "|fff", &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
     return NULL;
+  }
 …
   smpl_t output;
   if (!PyArg_ParseTuple (args, "|fff", &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR , &input, &samplerate, &fftsize)) {
     return NULL;
+  }
 …
   smpl_t output;
   if (!PyArg_ParseTuple (args, "|fff", &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
     return NULL;
+  }
 …
   smpl_t output;
   if (!PyArg_ParseTuple (args, "|fff", &input, &samplerate, &fftsize)) {
+  if (!PyArg_ParseTuple (args, "|" AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR AUBIO_NPY_SMPL_CHR, &input, &samplerate, &fftsize)) {
     return NULL;
+  }
 …
+{
   PyObject *input;
   fvec_t *vec;
+  fvec_t vec;
   PyObject *result;
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
     return NULL;
+  }
   // compute the function
   result = Py_BuildValue ("f", aubio_zero_crossing_rate (vec));
+  result = Py_BuildValue (AUBIO_NPY_SMPL_CHR, aubio_zero_crossing_rate (&vec));
   if (result == NULL) {
     return NULL;
 …
+{
   PyObject *input;
   fvec_t *vec;
+  fvec_t vec;
   if (!PyArg_ParseTuple (args, "O:min_removal", &input)) {
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
     return NULL;
+  }
   // compute the function
   fvec_min_removal (vec);
+  fvec_min_removal (&vec);
   // since this function does not return, we could return None
   //Py_RETURN_NONE;
   // however it is convenient to return the modified vector
   return (PyObject *) PyAubio_CFvecToArray(vec);
+  return (PyObject *) PyAubio_CFvecToArray(&vec);
   // or even without converting it back to an array
   //Py_INCREF(vec);
 …
   {"level_detection", Py_aubio_level_detection, METH_VARARGS, Py_aubio_level_detection_doc},
   {"window", Py_aubio_window, METH_VARARGS, Py_aubio_window_doc},
   {NULL, NULL} /* Sentinel */
+  {NULL, NULL, 0, NULL} /* Sentinel */
 };
+PyMODINIT_FUNC
+init_aubio (void)
+{
+  PyObject *m;
+#if PY_MAJOR_VERSION >= 3
+// Python3 module definition
+static struct PyModuleDef moduledef = {
+   PyModuleDef_HEAD_INIT,
+   "_aubio",          /* m_name */
+   aubio_module_doc,  /* m_doc */
+   -1,                /* m_size */
+   aubio_methods,     /* m_methods */
+   NULL,              /* m_reload */
+   NULL,              /* m_traverse */
+   NULL,              /* m_clear */
+   NULL,              /* m_free */
+};
+#endif
+static PyObject *
+initaubio (void)
+{
+  PyObject *m = NULL;
   int err;
 …
       || (generated_types_ready() < 0 )
   ) {
+    return;
+  }
+    return m;
+  }
+#if PY_MAJOR_VERSION >= 3
+  m = PyModule_Create(&moduledef);
+#else
   m = Py_InitModule3 ("_aubio", aubio_methods, aubio_module_doc);
+#endif
   if (m == NULL) {
     return;
+    return m;
+  }
 …
   PyModule_AddObject (m, "sink", (PyObject *) & Py_sinkType);
+  PyModule_AddStringConstant(m, "float_type", AUBIO_NPY_SMPL_STR);
   // add generated objects
   add_generated_objects(m);
 …
   // add ufunc
   add_ufuncs(m);
+}
+  return m;
+}
+#if PY_MAJOR_VERSION >= 3
+    // Python3 init
+    PyMODINIT_FUNC PyInit__aubio(void)
+    {
+        return initaubio();
+    }
+#else
+    // Python 2 init
+    PyMODINIT_FUNC init_aubio(void)
+    {
+        initaubio();
+    }
+#endif

python/ext/aubioproxy.c

-                      r60fc05b
+                      rf264b17
 #include "aubio-types.h"
+fvec_t *
+PyAubio_ArrayToCFvec (PyObject *input) {
+  PyObject *array;
+  fvec_t *vec;
+  if (input == NULL) {
+    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
+    goto fail;
+  }
+  // parsing input object into a Py_fvec
+  if (PyArray_Check(input)) {
+PyObject *
+new_py_fvec(uint_t length) {
+    npy_intp dims[] = { length, 1 };
+    return PyArray_ZEROS(1, dims, AUBIO_NPY_SMPL, 0);
+}
+    // we got an array, convert it to an fvec
+    if (PyArray_NDIM ((PyArrayObject *)input) == 0) {
+      PyErr_SetString (PyExc_ValueError, "input array is a scalar");
+      goto fail;
+    } else if (PyArray_NDIM ((PyArrayObject *)input) > 1) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array has more than one dimensions");
+      goto fail;
+    }
+    if (!PyArray_ISFLOAT ((PyArrayObject *)input)) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float");
+      goto fail;
+    } else if (PyArray_TYPE ((PyArrayObject *)input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      goto fail;
+    } else {
+      // input data type is float32, nothing else to do
+      array = input;
+    }
+    // vec = new_fvec (vec->length);
+    // no need to really allocate fvec, just its struct member
+    vec = (fvec_t *)malloc(sizeof(fvec_t));
+    long length = PyArray_SIZE ((PyArrayObject *)array);
+    if (length > 0) {
+      vec->length = (uint_t)length;
+    } else {
+      PyErr_SetString (PyExc_ValueError, "input array size should be greater than 0");
+      goto fail;
+    }
+    vec->data = (smpl_t *) PyArray_GETPTR1 ((PyArrayObject *)array, 0);
+  } else if (PyObject_TypeCheck (input, &PyList_Type)) {
+    PyErr_SetString (PyExc_ValueError, "does not convert from list yet");
+    return NULL;
+  } else {
+    PyErr_SetString (PyExc_ValueError, "can only accept vector of float as input");
+    return NULL;
+  }
+  return vec;
+fail:
+  return NULL;
+PyObject *
+new_py_fmat(uint_t height, uint_t length) {
+    npy_intp dims[] = { height, length, 1 };
+    return PyArray_ZEROS(2, dims, AUBIO_NPY_SMPL, 0);
+}
 …
+}
+Py_cvec *
+PyAubio_CCvecToPyCvec (cvec_t * input) {
+  Py_cvec *vec = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
+  vec->length = input->length;
+  vec->o = input;
+  Py_INCREF(vec);
+  return vec;
+int
+PyAubio_IsValidVector (PyObject * input) {
+  npy_intp length;
+  if (input == NULL) {
+    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
+    return 0;
+  }
+  // parsing input object into a Py_fvec
+  if (PyArray_Check(input)) {
+    // we got an array, convert it to an fvec
+    if (PyArray_NDIM ((PyArrayObject *)input) == 0) {
+      PyErr_SetString (PyExc_ValueError, "input array is a scalar");
+      return 0;
+    } else if (PyArray_NDIM ((PyArrayObject *)input) > 1) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array has more than one dimensions");
+      return 0;
+    }
+    if (!PyArray_ISFLOAT ((PyArrayObject *)input)) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float");
+      return 0;
+    } else if (PyArray_TYPE ((PyArrayObject *)input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be " AUBIO_NPY_SMPL_STR);
+      return 0;
+    }
+    length = PyArray_SIZE ((PyArrayObject *)input);
+    if (length <= 0) {
+      PyErr_SetString (PyExc_ValueError, "input array size should be greater than 0");
+      return 0;
+    }
+  } else if (PyObject_TypeCheck (input, &PyList_Type)) {
+    PyErr_SetString (PyExc_ValueError, "does not convert from list yet");
+    return 0;
+  } else {
+    PyErr_SetString (PyExc_ValueError, "can only accept vector of float as input");
+    return 0;
+  }
+  return 1;
+}
+cvec_t *
+PyAubio_ArrayToCCvec (PyObject *input) {
+  if (PyObject_TypeCheck (input, &Py_cvecType)) {
+      return ((Py_cvec*)input)->o;
+  } else {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      return NULL;
+int
+PyAubio_ArrayToCFvec (PyObject *input, fvec_t *out) {
+  if (!PyAubio_IsValidVector(input)){
+    return 0;
+  }
+  out->length = (uint_t) PyArray_SIZE ((PyArrayObject *)input);
+  out->data = (smpl_t *) PyArray_GETPTR1 ((PyArrayObject *)input, 0);
+  return 1;
+}
 …
+}
+fmat_t *
+PyAubio_ArrayToCFmat (PyObject *input) {
+  PyObject *array;
+  fmat_t *mat;
+  uint_t i;
+int
+PyAubio_ArrayToCFmat (PyObject *input, fmat_t *mat) {
+  uint_t i, new_height;
+  npy_intp length, height;
   if (input == NULL) {
     PyErr_SetString (PyExc_ValueError, "input array is not a python object");
     goto fail;
+    return 0;
+  }
   // parsing input object into a Py_fvec
 …
     if (PyArray_NDIM ((PyArrayObject *)input) == 0) {
       PyErr_SetString (PyExc_ValueError, "input array is a scalar");
       goto fail;
+      return 0;
     } else if (PyArray_NDIM ((PyArrayObject *)input) > 2) {
       PyErr_SetString (PyExc_ValueError,
           "input array has more than two dimensions");
       goto fail;
+      return 0;
+    }
     if (!PyArray_ISFLOAT ((PyArrayObject *)input)) {
       PyErr_SetString (PyExc_ValueError, "input array should be float");
       goto fail;
+      return 0;
     } else if (PyArray_TYPE ((PyArrayObject *)input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      goto fail;
+    } else {
+      // input data type is float32, nothing else to do
+      array = input;
+      PyErr_SetString (PyExc_ValueError, "input array should be " AUBIO_NPY_SMPL_STR);
+      return 0;
+    }
     // no need to really allocate fvec, just its struct member
+    mat = (fmat_t *)malloc(sizeof(fmat_t));
+    long length = PyArray_DIM ((PyArrayObject *)array, 1);
+    if (length > 0) {
+      mat->length = (uint_t)length;
+    } else {
+    length = PyArray_DIM ((PyArrayObject *)input, 1);
+    if (length <= 0) {
       PyErr_SetString (PyExc_ValueError, "input array dimension 1 should be greater than 0");
       goto fail;
+      return 0;
+    }
+    long height = PyArray_DIM ((PyArrayObject *)array, 0);
+    if (height > 0) {
+      mat->height = (uint_t)height;
+    } else {
+    height = PyArray_DIM ((PyArrayObject *)input, 0);
+    if (height <= 0) {
       PyErr_SetString (PyExc_ValueError, "input array dimension 0 should be greater than 0");
+      goto fail;
+    }
+    mat->data = (smpl_t **)malloc(sizeof(smpl_t*) * mat->height);
+    for (i=0; i< mat->height; i++) {
+      mat->data[i] = (smpl_t*)PyArray_GETPTR1 ((PyArrayObject *)array, i);
+      return 0;
+    }
   } else if (PyObject_TypeCheck (input, &PyList_Type)) {
     PyErr_SetString (PyExc_ValueError, "can not convert list to fmat");
     return NULL;
+    return 0;
   } else {
     PyErr_SetString (PyExc_ValueError, "can only accept matrix of float as input");
     return NULL;
+    return 0;
+  }
+  return mat;
+  new_height = (uint_t)PyArray_DIM ((PyArrayObject *)input, 0);
+  if (mat->height != new_height) {
+    if (mat->data) {
+      free(mat->data);
+    }
+    mat->data = (smpl_t **)malloc(sizeof(smpl_t*) * new_height);
+  }
+fail:
+  return NULL;
+  mat->height = new_height;
+  mat->length = (uint_t)PyArray_DIM ((PyArrayObject *)input, 1);
+  for (i=0; i< mat->height; i++) {
+    mat->data[i] = (smpl_t*)PyArray_GETPTR1 ((PyArrayObject *)input, i);
+  }
+  return 1;
+}

python/ext/py-cvec.c

-                      r60fc05b
+                      rf264b17
 #include "aubio-types.h"
 /* cvec type definition
+/* cvec type definition
 class cvec():
     def __init__(self, length = 1024):
         self.length = length
         self.norm = array(length)
         self.phas = array(length)
+    def __new__(self, length = 1024):
+        self.length = length / 2 + 1
+        self.norm = np.zeros(length / 2 + 1)
+        self.phas = np.zeros(length / 2 + 1)
 */
+// special python type for cvec
+typedef struct
+{
+  PyObject_HEAD
+  PyObject *norm;
+  PyObject *phas;
+  uint_t length;
+} Py_cvec;
 static char Py_cvec_doc[] = "cvec object";
+PyObject *
+new_py_cvec(uint_t length) {
+  Py_cvec* vec = (Py_cvec*) PyObject_New (Py_cvec, &Py_cvecType);
+  npy_intp dims[] = { length / 2 + 1, 1 };
+  vec->norm = PyArray_ZEROS(1, dims, AUBIO_NPY_SMPL, 0);
+  vec->phas = PyArray_ZEROS(1, dims, AUBIO_NPY_SMPL, 0);
+  vec->length = length / 2 + 1;
+  return (PyObject*)vec;
+}
+int
+PyAubio_PyCvecToCCvec (PyObject *input, cvec_t *i) {
+  if (PyObject_TypeCheck (input, &Py_cvecType)) {
+      Py_cvec * in = (Py_cvec *)input;
+      i->norm = (smpl_t *) PyArray_GETPTR1 ((PyArrayObject *)(in->norm), 0);
+      i->phas = (smpl_t *) PyArray_GETPTR1 ((PyArrayObject *)(in->phas), 0);
+      i->length = ((Py_cvec*)input)->length;
+      return 1;
+  } else {
+      PyErr_SetString (PyExc_ValueError, "input array should be aubio.cvec");
+      return 0;
+  }
+}
 static PyObject *
 …
     return NULL;
+  }
   self = (Py_cvec *) type->tp_alloc (type, 0);
 …
 Py_cvec_init (Py_cvec * self, PyObject * args, PyObject * kwds)
+{
+  self->o = new_cvec ((self->length - 1) * 2);
+  if (self->o == NULL) {
+    return -1;
+  }
+  npy_intp dims[] = { self->length, 1 };
+  self->phas = PyArray_ZEROS(1, dims, AUBIO_NPY_SMPL, 0);
+  self->norm = PyArray_ZEROS(1, dims, AUBIO_NPY_SMPL, 0);
   return 0;
+}
 …
 Py_cvec_del (Py_cvec * self)
+{
+  del_cvec (self->o);
+  self->ob_type->tp_free ((PyObject *) self);
+  Py_DECREF(self->norm);
+  Py_DECREF(self->phas);
+  Py_TYPE(self)->tp_free ((PyObject *) self);
+}
 …
   PyObject *result = NULL;
   format = PyString_FromString ("aubio cvec of %d elements");
+  format = PyUnicode_FromString ("aubio cvec of %d elements");
   if (format == NULL) {
     goto fail;
 …
     goto fail;
+  }
   cvec_print ( self->o );
   result = PyString_Format (format, args);
+  // hide actual norm / phas content
+  result = PyUnicode_Format (format, args);
 fail:
 …
 PyObject *
-PyAubio_CvecNormToArray (Py_cvec * self)
+{
-  npy_intp dims[] = { self->o->length, 1 };
-  return PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->norm);
+}
-PyObject *
-PyAubio_CvecPhasToArray (Py_cvec * self)
+{
-  npy_intp dims[] = { self->o->length, 1 };
-  return PyArray_SimpleNewFromData (1, dims, NPY_FLOAT, self->o->phas);
+}
-PyObject *
-PyAubio_ArrayToCvecPhas (PyObject * self)
+{
-  return NULL;
+}
-PyObject *
 Py_cvec_get_norm (Py_cvec * self, void *closure)
+{
+  return PyAubio_CvecNormToArray(self);
+  // we want self->norm to still exist after our caller return it
+  Py_INCREF(self->norm);
+  return (PyObject*)(self->norm);
+}
 …
 Py_cvec_get_phas (Py_cvec * self, void *closure)
+{
+  return PyAubio_CvecPhasToArray(self);
+  // we want self->phas to still exist after our caller return it
+  Py_INCREF(self->phas);
+  return (PyObject *)(self->phas);
+}
 …
 Py_cvec_set_norm (Py_cvec * vec, PyObject *input, void * closure)
+{
+  PyArrayObject * array;
+  if (input == NULL) {
+    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
+    goto fail;
+  }
+  if (PyArray_Check(input)) {
+    // we got an array, convert it to a cvec.norm
+    if (PyArray_NDIM ((PyArrayObject *)input) == 0) {
+      PyErr_SetString (PyExc_ValueError, "input array is a scalar");
+      goto fail;
+    } else if (PyArray_NDIM ((PyArrayObject *)input) > 2) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array has more than two dimensions");
+      goto fail;
+    }
+    if (!PyArray_ISFLOAT ((PyArrayObject *)input)) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float");
+      goto fail;
+    } else if (PyArray_TYPE ((PyArrayObject *)input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      goto fail;
+    }
+    array = (PyArrayObject *)input;
+    // check input array dimensions
+    if (PyArray_NDIM (array) != 1) {
+      PyErr_Format (PyExc_ValueError,
+          "input array has %d dimensions, not 1",
+          PyArray_NDIM (array));
+      goto fail;
+    } else {
+      if (vec->o->length != PyArray_SIZE (array)) {
+          PyErr_Format (PyExc_ValueError,
+                  "input array has length %d, but cvec has length %d",
+                  (int)PyArray_SIZE (array), vec->o->length);
+          goto fail;
+      }
+    }
+    vec->o->norm = (smpl_t *) PyArray_GETPTR1 (array, 0);
+  } else {
+    PyErr_SetString (PyExc_ValueError, "can only accept array as input");
+    return 1;
+  }
+  Py_INCREF(array);
+  npy_intp length;
+  if (!PyAubio_IsValidVector(input)) {
+    return 1;
+  }
+  length = PyArray_SIZE ((PyArrayObject *)input);
+  if (length != vec->length) {
+    PyErr_Format (PyExc_ValueError,
+        "input array has length %ld, but cvec has length %d", length,
+        vec->length);
+    return 1;
+  }
+  Py_XDECREF(vec->norm);
+  vec->norm = input;
+  Py_INCREF(vec->norm);
   return 0;
-fail:
-  return 1;
+}
 …
 Py_cvec_set_phas (Py_cvec * vec, PyObject *input, void * closure)
+{
+  PyArrayObject * array;
+  if (input == NULL) {
+    PyErr_SetString (PyExc_ValueError, "input array is not a python object");
+    goto fail;
+  }
+  if (PyArray_Check(input)) {
+    // we got an array, convert it to a cvec.phas
+    if (PyArray_NDIM ((PyArrayObject *)input) == 0) {
+      PyErr_SetString (PyExc_ValueError, "input array is a scalar");
+      goto fail;
+    } else if (PyArray_NDIM ((PyArrayObject *)input) > 2) {
+      PyErr_SetString (PyExc_ValueError,
+          "input array has more than two dimensions");
+      goto fail;
+    }
+    if (!PyArray_ISFLOAT ((PyArrayObject *)input)) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float");
+      goto fail;
+    } else if (PyArray_TYPE ((PyArrayObject *)input) != AUBIO_NPY_SMPL) {
+      PyErr_SetString (PyExc_ValueError, "input array should be float32");
+      goto fail;
+    }
+    array = (PyArrayObject *)input;
+    // check input array dimensions
+    if (PyArray_NDIM (array) != 1) {
+      PyErr_Format (PyExc_ValueError,
+          "input array has %d dimensions, not 1",
+          PyArray_NDIM (array));
+      goto fail;
+    } else {
+      if (vec->o->length != PyArray_SIZE (array)) {
+          PyErr_Format (PyExc_ValueError,
+                  "input array has length %d, but cvec has length %d",
+                  (int)PyArray_SIZE (array), vec->o->length);
+          goto fail;
+      }
+    }
+    vec->o->phas = (smpl_t *) PyArray_GETPTR1 (array, 0);
+  } else {
+    PyErr_SetString (PyExc_ValueError, "can only accept array as input");
+    return 1;
+  }
+  Py_INCREF(array);
+  npy_intp length;
+  if (!PyAubio_IsValidVector(input)) {
+    return 1;
+  }
+  length = PyArray_SIZE ((PyArrayObject *)input);
+  if (length != vec->length) {
+    PyErr_Format (PyExc_ValueError,
+        "input array has length %ld, but cvec has length %d", length,
+        vec->length);
+    return 1;
+  }
+  Py_XDECREF(vec->phas);
+  vec->phas = input;
+  Py_INCREF(vec->phas);
   return 0;
-fail:
-  return 1;
+}
 …
 PyTypeObject Py_cvecType = {
+  PyObject_HEAD_INIT (NULL)
+,                            /* ob_size           */
+  PyVarObject_HEAD_INIT(NULL, 0)
   "aubio.cvec",                 /* tp_name           */
   sizeof (Py_cvec),             /* tp_basicsize      */
 …
   (reprfunc) Py_cvec_repr,      /* tp_repr           */
 ,                            /* tp_as_number      */
 , //&Py_cvec_tp_as_sequence,      /* tp_as_sequence    */
+, //&Py_cvec_tp_as_sequence, /* tp_as_sequence    */
 ,                            /* tp_as_mapping     */
 ,                            /* tp_hash           */
 …
 ,                            /* tp_alloc          */
   Py_cvec_new,                  /* tp_new            */
+};
+,
+,
+,
+,
+,
+,
+,
+,
+,
+};

python/ext/py-fft.c

-                      r60fc05b
+                      rf264b17
 #include "aubiowraphell.h"
+#include "aubio-types.h"
 static char Py_fft_doc[] = "fft object";
+AUBIO_DECLARE(fft, uint_t win_s)
+typedef struct
+{
+  PyObject_HEAD
+  aubio_fft_t * o;
+  uint_t win_s;
+  // do / rdo input vectors
+  fvec_t vecin;
+  cvec_t cvecin;
+  // do / rdo output results
+  PyObject *doout;
+  PyObject *rdoout;
+} Py_fft;
-//AUBIO_NEW(fft)
 static PyObject *
 Py_fft_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
 …
+}
+static int
+Py_fft_init (Py_fft * self, PyObject * args, PyObject * kwds)
+{
+  self->o = new_aubio_fft (self->win_s);
+  if (self->o == NULL) {
+    PyErr_Format(PyExc_RuntimeError,
+        "error creating fft with win_s=%d "
+        "(should be a power of 2 greater than 1; "
+        "try recompiling aubio with --enable-fftw3)",
+        self->win_s);
+    return -1;
+  }
+AUBIO_INIT(fft, self->win_s)
+  self->doout = new_py_cvec(self->win_s);
+  self->rdoout = new_py_fvec(self->win_s);
+AUBIO_DEL(fft)
+  return 0;
+}
+static PyObject *
+Py_fft_do(PyObject * self, PyObject * args)
+static void
+Py_fft_del (Py_fft *self, PyObject *unused)
+{
+  Py_XDECREF(self->doout);
+  Py_XDECREF(self->rdoout);
+  if (self->o) {
+    del_aubio_fft(self->o);
+  }
+  Py_TYPE(self)->tp_free((PyObject *) self);
+}
+static PyObject *
+Py_fft_do(Py_fft * self, PyObject * args)
+{
   PyObject *input;
+  fvec_t *vec;
+  cvec_t *output;
+  cvec_t c_out;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &(self->vecin))) {
     return NULL;
+  }
+  output = new_cvec(((Py_fft *) self)->win_s);
+  if (self->vecin.length != self->win_s) {
+    PyErr_Format(PyExc_ValueError,
+                 "input array has length %d, but fft expects length %d",
+                 self->vecin.length, self->win_s);
+    return NULL;
+  }
+  Py_INCREF(self->doout);
+  if (!PyAubio_PyCvecToCCvec(self->doout, &c_out)) {
+    return NULL;
+  }
   // compute the function
   aubio_fft_do (((Py_fft *)self)->o, vec, output);
   return (PyObject *)PyAubio_CCvecToPyCvec(output);
+  aubio_fft_do (self->o, &(self->vecin), &c_out);
+  return self->doout;
+}
+AUBIO_MEMBERS_START(fft)
+static PyMemberDef Py_fft_members[] = {
   {"win_s", T_INT, offsetof (Py_fft, win_s), READONLY,
     "size of the window"},
+AUBIO_MEMBERS_STOP(fft)
+  {NULL}
+};
 static PyObject *
+static PyObject *
 Py_fft_rdo(Py_fft * self, PyObject * args)
+{
   PyObject *input;
+  cvec_t *vec;
+  fvec_t *output;
+  fvec_t out;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
+  vec = PyAubio_ArrayToCCvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_PyCvecToCCvec (input, &(self->cvecin)) ) {
     return NULL;
+  }
+  output = new_fvec(self->win_s);
+  if (self->cvecin.length != self->win_s / 2 + 1) {
+    PyErr_Format(PyExc_ValueError,
+                 "input cvec has length %d, but fft expects length %d",
+                 self->cvecin.length, self->win_s / 2 + 1);
+    return NULL;
+  }
+  Py_INCREF(self->rdoout);
+  if (!PyAubio_ArrayToCFvec(self->rdoout, &out) ) {
+    return NULL;
+  }
   // compute the function
   aubio_fft_rdo (((Py_fft *)self)->o, vec, output);
   return (PyObject *)PyAubio_CFvecToArray(output);
+  aubio_fft_rdo (self->o, &(self->cvecin), &out);
+  return self->rdoout;
+}
 …
 };
+AUBIO_TYPEOBJECT(fft, "aubio.fft")
+PyTypeObject Py_fftType = {
+  PyVarObject_HEAD_INIT (NULL, 0)
+  "aubio.fft",
+  sizeof (Py_fft),
+,
+  (destructor) Py_fft_del,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+  (ternaryfunc)Py_fft_do,
+,
+,
+,
+,
+  Py_TPFLAGS_DEFAULT,
+  Py_fft_doc,
+,
+,
+,
+,
+,
+,
+  Py_fft_methods,
+  Py_fft_members,
+,
+,
+,
+,
+,
+,
+  (initproc) Py_fft_init,
+,
+  Py_fft_new,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+};

python/ext/py-filter.c

-                      r60fc05b
+                      rf264b17
   aubio_filter_t * o;
   uint_t order;
+  fvec_t vec;
+  PyObject *out;
+  fvec_t c_out;
 } Py_filter;
 …
     return -1;
+  }
+  self->out = NULL;
   return 0;
+}
 …
 Py_filter_del (Py_filter * self)
+{
+  Py_XDECREF(self->out);
   del_aubio_filter (self->o);
   self->ob_type->tp_free ((PyObject *) self);
+}
 static PyObject *
+  Py_TYPE(self)->tp_free ((PyObject *) self);
+}
+static PyObject *
 Py_filter_do(Py_filter * self, PyObject * args)
+{
   PyObject *input;
-  fvec_t *vec;
   if (!PyArg_ParseTuple (args, "O:digital_filter.do", &input)) {
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+    return NULL;
+  }
+  if (!PyAubio_ArrayToCFvec(input, &(self->vec))) {
+    return NULL;
+  }
+  // initialize output now
+  if (self->out == NULL) {
+    self->out = new_py_fvec(self->vec.length);
+  }
+  Py_INCREF(self->out);
+  if (!PyAubio_ArrayToCFvec(self->out, &(self->c_out)) ) {
+    return NULL;
+  }
   // compute the function
+  fvec_t * out = new_fvec(vec->length);
+  aubio_filter_do_outplace (self->o, vec, out);
+  return PyAubio_CFvecToArray(out);
+}
+static PyObject *
+  aubio_filter_do_outplace (self->o, &(self->vec), &(self->c_out));
+  return self->out;
+}
+static PyObject *
 Py_filter_set_c_weighting (Py_filter * self, PyObject *args)
+{
 …
+}
 static PyObject *
+static PyObject *
 Py_filter_set_a_weighting (Py_filter * self, PyObject *args)
+{
 …
 PyTypeObject Py_filterType = {
+  PyObject_HEAD_INIT (NULL)
+,                            /* ob_size           */
+  PyVarObject_HEAD_INIT(NULL, 0)
   "aubio.digital_filter",       /* tp_name           */
   sizeof (Py_filter),           /* tp_basicsize      */
 …
 ,                            /* tp_alloc          */
   Py_filter_new,                /* tp_new            */
+,
+,
+,
+,
+,
+,
+,
+,
+,
 };

python/ext/py-filterbank.c

-                      r60fc05b
+                      rf264b17
 #include "aubiowraphell.h"
+#include "aubio-types.h"
 static char Py_filterbank_doc[] = "filterbank object";
+AUBIO_DECLARE(filterbank, uint_t n_filters; uint_t win_s)
+//AUBIO_NEW(filterbank)
+typedef struct
+{
+  PyObject_HEAD
+  aubio_filterbank_t * o;
+  uint_t n_filters;
+  uint_t win_s;
+  cvec_t vec;
+  fvec_t freqs;
+  fmat_t coeffs;
+  PyObject *out;
+  fvec_t c_out;
+} Py_filterbank;
 static PyObject *
 Py_filterbank_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
 …
+}
+AUBIO_INIT(filterbank, self->n_filters, self->win_s)
+AUBIO_DEL(filterbank)
+static int
+Py_filterbank_init (Py_filterbank * self, PyObject * args, PyObject * kwds)
+{
+  self->o = new_aubio_filterbank (self->n_filters, self->win_s);
+  if (self->o == NULL) {
+    PyErr_Format(PyExc_RuntimeError, "error creating filterbank with"
+        " n_filters=%d, win_s=%d", self->n_filters, self->win_s);
+    return -1;
+  }
+  self->out = new_py_fvec(self->n_filters);
+  return 0;
+}
+static void
+Py_filterbank_del (Py_filterbank *self, PyObject *unused)
+{
+  if (self->o) {
+    free(self->coeffs.data);
+    del_aubio_filterbank(self->o);
+  }
+  Py_XDECREF(self->out);
+  Py_TYPE(self)->tp_free((PyObject *) self);
+}
 static PyObject *
 …
+{
   PyObject *input;
-  cvec_t *vec;
-  fvec_t *out;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
+  vec = PyAubio_ArrayToCCvec (input);
+  if (vec == NULL) {
+    return NULL;
+  }
+  out = new_fvec (self->n_filters);
+  if (!PyAubio_PyCvecToCCvec(input, &(self->vec) )) {
+    return NULL;
+  }
+  if (self->vec.length != self->win_s / 2 + 1) {
+    PyErr_Format(PyExc_ValueError,
+                 "input cvec has length %d, but fft expects length %d",
+                 self->vec.length, self->win_s / 2 + 1);
+    return NULL;
+  }
+  Py_INCREF(self->out);
+  if (!PyAubio_ArrayToCFvec(self->out, &(self->c_out))) {
+    return NULL;
+  }
   // compute the function
   aubio_filterbank_do (self->o, vec, out);
   return (PyObject *)PyAubio_CFvecToArray(out);
+}
+AUBIO_MEMBERS_START(filterbank)
+  aubio_filterbank_do (self->o, &(self->vec), &(self->c_out));
+  return self->out;
+}
+static PyMemberDef Py_filterbank_members[] = {
   {"win_s", T_INT, offsetof (Py_filterbank, win_s), READONLY,
     "size of the window"},
   {"n_filters", T_INT, offsetof (Py_filterbank, n_filters), READONLY,
     "number of filters"},
+AUBIO_MEMBERS_STOP(filterbank)
+  {NULL} /* sentinel */
+};
 static PyObject *
 …
   PyObject *input;
   uint_t samplerate;
-  fvec_t *freqs;
   if (!PyArg_ParseTuple (args, "OI", &input, &samplerate)) {
     return NULL;
 …
+  }
+  freqs = PyAubio_ArrayToCFvec (input);
+  if (freqs == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &(self->freqs) )) {
     return NULL;
+  }
   err = aubio_filterbank_set_triangle_bands (self->o,
       freqs, samplerate);
+      &(self->freqs), samplerate);
   if (err > 0) {
     PyErr_SetString (PyExc_ValueError,
 …
   PyObject *input;
-  fmat_t *coeffs;
   if (!PyArg_ParseTuple (args, "O", &input)) {
     return NULL;
+  }
+  coeffs = PyAubio_ArrayToCFmat (input);
+  if (coeffs == NULL) {
+    PyErr_SetString (PyExc_ValueError,
+        "unable to parse input array");
+    return NULL;
+  }
+  err = aubio_filterbank_set_coeffs (self->o, coeffs);
+  if (!PyAubio_ArrayToCFmat(input, &(self->coeffs))) {
+    return NULL;
+  }
+  err = aubio_filterbank_set_coeffs (self->o, &(self->coeffs));
   if (err > 0) {
 …
 };
+AUBIO_TYPEOBJECT(filterbank, "aubio.filterbank")
+PyTypeObject Py_filterbankType = {
+  PyVarObject_HEAD_INIT (NULL, 0)
+  "aubio.filterbank",
+  sizeof (Py_filterbank),
+,
+  (destructor) Py_filterbank_del,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+  (ternaryfunc)Py_filterbank_do,
+,
+,
+,
+,
+  Py_TPFLAGS_DEFAULT,
+  Py_filterbank_doc,
+,
+,
+,
+,
+,
+,
+  Py_filterbank_methods,
+  Py_filterbank_members,
+,
+,
+,
+,
+,
+,
+  (initproc) Py_filterbank_init,
+,
+  Py_filterbank_new,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+};

python/ext/py-musicutils.c

-                      r60fc05b
+                      rf264b17
   if (!PyArg_ParseTuple (args, "|sI", &wintype, &winlen)) {
-    PyErr_SetString (PyExc_ValueError, "failed parsing arguments");
     return NULL;
+  }
 …
+{
   PyObject *input;
   fvec_t *vec;
+  fvec_t vec;
   PyObject *level_lin;
   if (!PyArg_ParseTuple (args, "O:level_lin", &input)) {
-    PyErr_SetString (PyExc_ValueError, "failed parsing arguments");
     return NULL;
+  }
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
     return NULL;
+  }
   level_lin = Py_BuildValue("f", aubio_level_lin(vec));
+  level_lin = Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_level_lin(&vec));
   if (level_lin == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing level_lin");
 …
+{
   PyObject *input;
   fvec_t *vec;
+  fvec_t vec;
   PyObject *db_spl;
   if (!PyArg_ParseTuple (args, "O:db_spl", &input)) {
-    PyErr_SetString (PyExc_ValueError, "failed parsing arguments");
     return NULL;
+  }
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
     return NULL;
+  }
   db_spl = Py_BuildValue("f", aubio_db_spl(vec));
+  db_spl = Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_db_spl(&vec));
   if (db_spl == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing db_spl");
 …
+{
   PyObject *input;
   fvec_t *vec;
+  fvec_t vec;
   PyObject *silence_detection;
   smpl_t threshold;
+  if (!PyArg_ParseTuple (args, "Of:silence_detection", &input, &threshold)) {
+    PyErr_SetString (PyExc_ValueError, "failed parsing arguments");
+  if (!PyArg_ParseTuple (args, "O" AUBIO_NPY_SMPL_CHR ":silence_detection", &input, &threshold)) {
     return NULL;
+  }
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
     return NULL;
+  }
   silence_detection = Py_BuildValue("I", aubio_silence_detection(vec, threshold));
+  silence_detection = Py_BuildValue("I", aubio_silence_detection(&vec, threshold));
   if (silence_detection == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing silence_detection");
 …
+{
   PyObject *input;
   fvec_t *vec;
+  fvec_t vec;
   PyObject *level_detection;
   smpl_t threshold;
+  if (!PyArg_ParseTuple (args, "Of:level_detection", &input, &threshold)) {
+    PyErr_SetString (PyExc_ValueError, "failed parsing arguments");
+  if (!PyArg_ParseTuple (args, "O" AUBIO_NPY_SMPL_CHR ":level_detection", &input, &threshold)) {
     return NULL;
+  }
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+  if (!PyAubio_ArrayToCFvec(input, &vec)) {
     return NULL;
+  }
   level_detection = Py_BuildValue("f", aubio_level_detection(vec, threshold));
+  level_detection = Py_BuildValue(AUBIO_NPY_SMPL_CHR, aubio_level_detection(&vec, threshold));
   if (level_detection == NULL) {
     PyErr_SetString (PyExc_ValueError, "failed computing level_detection");

python/ext/py-musicutils.h

-                      r60fc05b
+                      rf264b17
 #ifndef _PY_AUBIO_MUSICUTILS_H_
 #define _PY_AUBIO_MUSICUTILS_H_
+#ifndef PY_AUBIO_MUSICUTILS_H
+#define PY_AUBIO_MUSICUTILS_H
 static char Py_aubio_window_doc[] = ""
 …
 PyObject * Py_aubio_level_detection(PyObject *self, PyObject *args);
 #endif /* _PY_AUBIO_MUSICUTILS_H_ */
+#endif /* PY_AUBIO_MUSICUTILS_H */

python/ext/py-phasevoc.c

-                      r60fc05b
+                      rf264b17
 #include "aubiowraphell.h"
+#include "aubio-types.h"
 static char Py_pvoc_doc[] = "pvoc object";
+AUBIO_DECLARE(pvoc, uint_t win_s; uint_t hop_s)
+//AUBIO_NEW(pvoc)
+typedef struct
+{
+  PyObject_HEAD
+  aubio_pvoc_t * o;
+  uint_t win_s;
+  uint_t hop_s;
+  fvec_t vecin;
+  cvec_t cvecin;
+  PyObject *output;
+  cvec_t c_output;
+  PyObject *routput;
+  fvec_t c_routput;
+} Py_pvoc;
 static PyObject *
 Py_pvoc_new (PyTypeObject * type, PyObject * args, PyObject * kwds)
 …
+}
+AUBIO_INIT(pvoc, self->win_s, self->hop_s)
+AUBIO_DEL(pvoc)
+static PyObject *
+static int
+Py_pvoc_init (Py_pvoc * self, PyObject * args, PyObject * kwds)
+{
+  self->o = new_aubio_pvoc ( self->win_s, self->hop_s);
+  if (self->o == NULL) {
+    PyErr_Format(PyExc_RuntimeError,
+        "failed creating pvoc with win_s=%d, hop_s=%d",
+        self->win_s, self->hop_s);
+    return -1;
+  }
+  self->output = new_py_cvec(self->win_s);
+  self->routput = new_py_fvec(self->hop_s);
+  return 0;
+}
+static void
+Py_pvoc_del (Py_pvoc *self, PyObject *unused)
+{
+  Py_XDECREF(self->output);
+  Py_XDECREF(self->routput);
+  if (self->o) {
+    del_aubio_pvoc(self->o);
+  }
+  Py_TYPE(self)->tp_free((PyObject *) self);
+}
+static PyObject *
 Py_pvoc_do(Py_pvoc * self, PyObject * args)
+{
   PyObject *input;
-  fvec_t *vec;
-  cvec_t *output;
   if (!PyArg_ParseTuple (args, "O", &input)) {
 …
+  }
+  vec = PyAubio_ArrayToCFvec (input);
+  if (vec == NULL) {
+    return NULL;
+  }
+  output = new_cvec(self->win_s);
+  if (!PyAubio_ArrayToCFvec (input, &(self->vecin) )) {
+    return NULL;
+  }
+  if (self->vecin.length != self->hop_s) {
+    PyErr_Format(PyExc_ValueError,
+                 "input fvec has length %d, but pvoc expects length %d",
+                 self->vecin.length, self->hop_s);
+    return NULL;
+  }
+  Py_INCREF(self->output);
+  if (!PyAubio_PyCvecToCCvec (self->output, &(self->c_output))) {
+    return NULL;
+  }
   // compute the function
   aubio_pvoc_do (self->o, vec, output);
   return (PyObject *)PyAubio_CCvecToPyCvec(output);
+}
+AUBIO_MEMBERS_START(pvoc)
+  aubio_pvoc_do (self->o, &(self->vecin), &(self->c_output));
+  return self->output;
+}
+static PyMemberDef Py_pvoc_members[] = {
   {"win_s", T_INT, offsetof (Py_pvoc, win_s), READONLY,
     "size of the window"},
   {"hop_s", T_INT, offsetof (Py_pvoc, hop_s), READONLY,
     "size of the hop"},
+AUBIO_MEMBERS_STOP(pvoc)
+static PyObject *
+  { NULL } // sentinel
+};
+static PyObject *
 Py_pvoc_rdo(Py_pvoc * self, PyObject * args)
+{
   PyObject *input;
-  cvec_t *vec;
-  fvec_t *output;
   if (!PyArg_ParseTuple (args, "O", &input)) {
     return NULL;
+  }
+  vec = PyAubio_ArrayToCCvec (input);
+  if (vec == NULL) {
+    return NULL;
+  }
+  output = new_fvec(self->hop_s);
+  if (!PyAubio_PyCvecToCCvec (input, &(self->cvecin) )) {
+    return NULL;
+  }
+  if (self->cvecin.length != self->win_s / 2 + 1) {
+    PyErr_Format(PyExc_ValueError,
+                 "input cvec has length %d, but pvoc expects length %d",
+                 self->cvecin.length, self->win_s / 2 + 1);
+    return NULL;
+  }
+  Py_INCREF(self->routput);
+  if (!PyAubio_ArrayToCFvec(self->routput, &(self->c_routput)) ) {
+    return NULL;
+  }
   // compute the function
   aubio_pvoc_rdo (self->o, vec, output);
   return (PyObject *)PyAubio_CFvecToArray(output);
+  aubio_pvoc_rdo (self->o, &(self->cvecin), &(self->c_routput));
+  return self->routput;
+}
 …
 };
+AUBIO_TYPEOBJECT(pvoc, "aubio.pvoc")
+PyTypeObject Py_pvocType = {
+  PyVarObject_HEAD_INIT (NULL, 0)
+  "aubio.pvoc",
+  sizeof (Py_pvoc),
+,
+  (destructor) Py_pvoc_del,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+  (ternaryfunc)Py_pvoc_do,
+,
+,
+,
+,
+  Py_TPFLAGS_DEFAULT,
+  Py_pvoc_doc,
+,
+,
+,
+,
+,
+,
+  Py_pvoc_methods,
+  Py_pvoc_members,
+,
+,
+,
+,
+,
+,
+  (initproc) Py_pvoc_init,
+,
+  Py_pvoc_new,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+};

python/ext/py-sink.c

-                      r60fc05b
+                      rf264b17
 #include "aubiowraphell.h"
+#include "aubio-types.h"
 typedef struct
 …
   uint_t samplerate;
   uint_t channels;
+  fvec_t write_data;
+  fmat_t mwrite_data;
 } Py_sink;
 …
+  }
   if (self->o == NULL) {
     PyErr_SetString (PyExc_StandardError, "error creating sink with this uri");
+    PyErr_SetString (PyExc_RuntimeError, "error creating sink with this uri");
     return -1;
+  }
 …
+}
+AUBIO_DEL(sink)
+static void
+Py_sink_del (Py_sink *self, PyObject *unused)
+{
+  del_aubio_sink(self->o);
+  free(self->mwrite_data.data);
+  Py_TYPE(self)->tp_free((PyObject *) self);
+}
 /* function Py_sink_do */
 …
   /* input vectors prototypes */
-  fvec_t* write_data;
   uint_t write;
 …
+  }
   /* input vectors parsing */
+  write_data = PyAubio_ArrayToCFvec (write_data_obj);
+  if (write_data == NULL) {
+    return NULL;
+  }
+  if (!PyAubio_ArrayToCFvec(write_data_obj, &(self->write_data))) {
+    return NULL;
+  }
   /* compute _do function */
   aubio_sink_do (self->o, write_data, write);
+  aubio_sink_do (self->o, &(self->write_data), write);
   Py_RETURN_NONE;
 …
   /* input vectors prototypes */
-  fmat_t * write_data;
   uint_t write;
 …
   /* input vectors parsing */
+  write_data = PyAubio_ArrayToCFmat (write_data_obj);
+  if (write_data == NULL) {
+    return NULL;
+  }
+  if (!PyAubio_ArrayToCFmat(write_data_obj, &(self->mwrite_data))) {
+    return NULL;
+  }
   /* compute _do function */
   aubio_sink_do_multi (self->o, write_data, write);
+  aubio_sink_do_multi (self->o, &(self->mwrite_data), write);
   Py_RETURN_NONE;
+}
+AUBIO_MEMBERS_START(sink)
+static PyMemberDef Py_sink_members[] = {
   {"uri", T_STRING, offsetof (Py_sink, uri), READONLY,
     "path at which the sink was created"},
 …
   {"channels", T_INT, offsetof (Py_sink, channels), READONLY,
     "number of channels with which the sink was created"},
+AUBIO_MEMBERS_STOP(sink)
+  { NULL } // sentinel
+};
 static PyObject *
 …
 };
+AUBIO_TYPEOBJECT(sink, "aubio.sink")
+PyTypeObject Py_sinkType = {
+  PyVarObject_HEAD_INIT (NULL, 0)
+  "aubio.sink",
+  sizeof (Py_sink),
+,
+  (destructor) Py_sink_del,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+  (ternaryfunc)Py_sink_do,
+,
+,
+,
+,
+  Py_TPFLAGS_DEFAULT,
+  Py_sink_doc,
+,
+,
+,
+,
+,
+,
+  Py_sink_methods,
+  Py_sink_members,
+,
+,
+,
+,
+,
+,
+  (initproc) Py_sink_init,
+,
+  Py_sink_new,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+};

python/ext/py-source.c

-                      r60fc05b
+                      rf264b17
 #include "aubiowraphell.h"
+#include "aubio-types.h"
 typedef struct
 …
   uint_t channels;
   uint_t hop_size;
+  uint_t duration;
+  PyObject *read_to;
+  fvec_t c_read_to;
+  PyObject *mread_to;
+  fmat_t c_mread_to;
 } Py_source;
 …
   self->o = new_aubio_source ( self->uri, self->samplerate, self->hop_size );
   if (self->o == NULL) {
+    char_t errstr[30 + strlen(self->uri)];
+    sprintf(errstr, "error creating source with %s", self->uri);
+    PyErr_SetString (PyExc_StandardError, errstr);
+    PyErr_Format (PyExc_RuntimeError, "error creating source with \"%s\"",
+        self->uri);
     return -1;
+  }
 …
     self->channels = aubio_source_get_channels ( self->o );
+  }
+  self->duration = aubio_source_get_duration ( self->o );
+  self->read_to = new_py_fvec(self->hop_size);
+  self->mread_to = new_py_fmat(self->channels, self->hop_size);
   return 0;
+}
+AUBIO_DEL(source)
+static void
+Py_source_del (Py_source *self, PyObject *unused)
+{
+  if (self->o) {
+    del_aubio_source(self->o);
+    free(self->c_mread_to.data);
+  }
+  Py_XDECREF(self->read_to);
+  Py_XDECREF(self->mread_to);
+  Py_TYPE(self)->tp_free((PyObject *) self);
+}
 /* function Py_source_do */
 …
 Py_source_do(Py_source * self, PyObject * args)
+{
+  /* output vectors prototypes */
+  fvec_t* read_to;
+  PyObject *outputs;
   uint_t read;
-  /* creating output read_to as a new_fvec of length self->hop_size */
-  read_to = new_fvec (self->hop_size);
   read = 0;
+  Py_INCREF(self->read_to);
+  if (!PyAubio_ArrayToCFvec(self->read_to, &(self->c_read_to))) {
+    return NULL;
+  }
   /* compute _do function */
+  aubio_source_do (self->o, read_to, &read);
+  PyObject *outputs = PyList_New(0);
+  PyList_Append( outputs, (PyObject *)PyAubio_CFvecToArray (read_to));
+  //del_fvec (read_to);
+  PyList_Append( outputs, (PyObject *)PyInt_FromLong (read));
+  aubio_source_do (self->o, &(self->c_read_to), &read);
+  outputs = PyTuple_New(2);
+  PyTuple_SetItem( outputs, 0, self->read_to );
+  PyTuple_SetItem( outputs, 1, (PyObject *)PyLong_FromLong(read));
   return outputs;
+}
 …
 Py_source_do_multi(Py_source * self, PyObject * args)
+{
+  /* output vectors prototypes */
+  fmat_t* read_to;
+  PyObject *outputs;
   uint_t read;
-  /* creating output read_to as a new_fvec of length self->hop_size */
-  read_to = new_fmat (self->channels, self->hop_size);
   read = 0;
+  Py_INCREF(self->mread_to);
+  if (!PyAubio_ArrayToCFmat(self->mread_to,  &(self->c_mread_to))) {
+    return NULL;
+  }
   /* compute _do function */
+  aubio_source_do_multi (self->o, read_to, &read);
+  PyObject *outputs = PyList_New(0);
+  PyList_Append( outputs, (PyObject *)PyAubio_CFmatToArray (read_to));
+  //del_fvec (read_to);
+  PyList_Append( outputs, (PyObject *)PyInt_FromLong (read));
+  aubio_source_do_multi (self->o, &(self->c_mread_to), &read);
+  outputs = PyTuple_New(2);
+  PyTuple_SetItem( outputs, 0, self->mread_to);
+  PyTuple_SetItem( outputs, 1, (PyObject *)PyLong_FromLong(read));
   return outputs;
+}
+AUBIO_MEMBERS_START(source)
+static PyMemberDef Py_source_members[] = {
   {"uri", T_STRING, offsetof (Py_source, uri), READONLY,
     "path at which the source was created"},
 …
   {"hop_size", T_INT, offsetof (Py_source, hop_size), READONLY,
     "number of consecutive frames that will be read at each do or do_multi call"},
+AUBIO_MEMBERS_STOP(source)
+  {"duration", T_INT, offsetof (Py_source, duration), READONLY,
+    "total number of frames in the source (estimated)"},
+  { NULL } // sentinel
+};
 static PyObject *
 …
+{
   uint_t tmp = aubio_source_get_samplerate (self->o);
   return (PyObject *)PyInt_FromLong (tmp);
+  return (PyObject *)PyLong_FromLong (tmp);
+}
 …
+{
   uint_t tmp = aubio_source_get_channels (self->o);
   return (PyObject *)PyInt_FromLong (tmp);
+  return (PyObject *)PyLong_FromLong (tmp);
+}
 …
   uint_t err = 0;
   uint_t position;
+  int position;
   if (!PyArg_ParseTuple (args, "I", &position)) {
+    return NULL;
+  }
+  if (position < 0) {
+    PyErr_Format(PyExc_ValueError,
+        "error when seeking in source: can not seek to negative value %d",
+        position);
     return NULL;
+  }
 …
 };
+AUBIO_TYPEOBJECT(source, "aubio.source")
+PyTypeObject Py_sourceType = {
+  PyVarObject_HEAD_INIT (NULL, 0)
+  "aubio.source",
+  sizeof (Py_source),
+,
+  (destructor) Py_source_del,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+  (ternaryfunc)Py_source_do,
+,
+,
+,
+,
+  Py_TPFLAGS_DEFAULT,
+  Py_source_doc,
+,
+,
+,
+,
+,
+,
+  Py_source_methods,
+  Py_source_members,
+,
+,
+,
+,
+,
+,
+  (initproc) Py_source_init,
+,
+  Py_source_new,
+,
+,
+,
+,
+,
+,
+,
+,
+,
+};

python/ext/ufuncs.c

-                      r60fc05b
+                      rf264b17
+{
   int err = 0;
+  PyObject *dict, *f, *g, *h;
   err = _import_umath ();
 …
+  }
-  PyObject *f, *dict;
   dict = PyModule_GetDict(m);
   f = PyUFunc_FromFuncAndData(Py_aubio_unary_functions, Py_unwrap2pi_data, Py_aubio_unary_types,
 …
   Py_DECREF(f);
-  PyObject *g;
   g = PyUFunc_FromFuncAndData(Py_aubio_unary_functions, Py_freqtomidi_data, Py_aubio_unary_types,
           Py_aubio_unary_n_types, Py_aubio_unary_n_inputs, Py_aubio_unary_n_outputs,
 …
   Py_DECREF(g);
-  PyObject *h;
   h = PyUFunc_FromFuncAndData(Py_aubio_unary_functions, Py_miditofreq_data, Py_aubio_unary_types,
           Py_aubio_unary_n_types, Py_aubio_unary_n_inputs, Py_aubio_unary_n_outputs,

python/lib/aubio/init.py

-                      r60fc05b
+                      rf264b17
 import numpy
+from _aubio import *
+from midiconv import *
+from slicing import *
+from ._aubio import *
+from ._aubio import float_type
+from .midiconv import *
+from .slicing import *
 class fvec(numpy.ndarray):
+    " a simple numpy array holding a vector of float32 "
+    def __new__(self, length = 1024, **kwargs):
+        self.length = length
+        if type(length) == type([]):
+            return numpy.array(length, dtype='float32', **kwargs)
+        return numpy.zeros(length, dtype='float32', **kwargs)
+    """a numpy vector holding audio samples"""
+    def __new__(cls, input_arg=1024, **kwargs):
+        if isinstance(input_arg, int):
+            if input_arg == 0:
+                raise ValueError("vector length of 1 or more expected")
+            return numpy.zeros(input_arg, dtype=float_type, **kwargs)
+        else:
+            return numpy.array(input_arg, dtype=float_type, **kwargs)

python/lib/aubio/midiconv.py

-                      r60fc05b
+                      rf264b17
 # -*- coding: utf-8 -*-
+""" utilities to convert midi note number to and from note names """
+__all__ = ['note2midi', 'midi2note', 'freq2note']
+import sys
+py3 = sys.version_info[0] == 3
+if py3:
+    str_instances = str
+    int_instances = int
+else:
+    str_instances = (str, unicode)
+    int_instances = (int, long)
 def note2midi(note):
     " convert note name to midi note number, e.g. [C-1, G9] -> [0, 127] "
     _valid_notenames = {'C': 0, 'D': 2, 'E': 4, 'F': 5, 'G': 7, 'A': 9, 'B': 11}
+    _valid_modifiers = {None: 0, u'♮': 0, '#': +1, u'♯': +1, u'\udd2a': +2, 'b': -1, u'♭': -1, u'\ufffd': -2}
+    _valid_modifiers = {None: 0, u'♮': 0, '#': +1, u'♯': +1, u'\udd2a': +2,
+                        'b': -1, u'♭': -1, u'\ufffd': -2}
     _valid_octaves = range(-1, 10)
+    if type(note) not in (str, unicode):
+        raise TypeError, "a string is required, got %s" % note
+    if not (1 < len(note) < 5):
+        raise ValueError, "string of 2 to 4 characters expected, got %d (%s)" % (len(note), note)
+    if not isinstance(note, str_instances):
+        raise TypeError("a string is required, got %s (%s)" % (note, str(type(note))))
+    if len(note) not in range(2, 5):
+        raise ValueError("string of 2 to 4 characters expected, got %d (%s)" \
+                         % (len(note), note))
     notename, modifier, octave = [None]*3
 …
     if notename not in _valid_notenames:
         raise ValueError, "%s is not a valid note name" % notename
+        raise ValueError("%s is not a valid note name" % notename)
     if modifier not in _valid_modifiers:
         raise ValueError, "%s is not a valid modifier" % modifier
+        raise ValueError("%s is not a valid modifier" % modifier)
     if octave not in _valid_octaves:
         raise ValueError, "%s is not a valid octave" % octave
+        raise ValueError("%s is not a valid octave" % octave)
     midi = 12 + octave * 12 + _valid_notenames[notename] + _valid_modifiers[modifier]
     if midi > 127:
         raise ValueError, "%s is outside of the range C-2 to G8" % note
+        raise ValueError("%s is outside of the range C-2 to G8" % note)
     return midi
 def midi2note(midi):
     " convert midi note number to note name, e.g. [0, 127] -> [C-1, G9] "
+    if type(midi) != int:
+        raise TypeError, "an integer is required, got %s" % midi
+    if not (-1 < midi < 128):
+        raise ValueError, "an integer between 0 and 127 is excepted, got %d" % midi
+    midi = int(midi)
+    if not isinstance(midi, int_instances):
+        raise TypeError("an integer is required, got %s" % midi)
+    if midi not in range(0, 128):
+        raise ValueError("an integer between 0 and 127 is excepted, got %d" % midi)
     _valid_notenames = ['C', 'C#', 'D', 'D#', 'E', 'F', 'F#', 'G', 'G#', 'A', 'A#', 'B']
     return _valid_notenames[midi % 12] + str( midi / 12 - 1)
+    return _valid_notenames[midi % 12] + str(int(midi / 12) - 1)
 def freq2note(freq):
+    " convert frequency in Hz to nearest note name, e.g. [0, 22050.] -> [C-1, G9] "
     from aubio import freqtomidi
     return midi2note(int(freqtomidi(freq)))

python/lib/aubio/slicing.py

-                      r60fc05b
+                      rf264b17
+"""utility routines to slice sound files at given timestamps"""
+import os
 from aubio import source, sink
-import os
 max_timestamp = 1e120
+_max_timestamp = 1e120
+def slice_source_at_stamps(source_file, timestamps, timestamps_end = None,
+        output_dir = None,
+        samplerate = 0,
+        hopsize = 256):
+def slice_source_at_stamps(source_file, timestamps, timestamps_end=None,
+                           output_dir=None, samplerate=0, hopsize=256):
+    """ slice a sound file at given timestamps """
     if timestamps == None or len(timestamps) == 0:
         raise ValueError ("no timestamps given")
+    if timestamps is None or len(timestamps) == 0:
+        raise ValueError("no timestamps given")
     if timestamps[0] != 0:
         timestamps = [0] + timestamps
         if timestamps_end != None:
+        if timestamps_end is not None:
             timestamps_end = [timestamps[1] - 1] + timestamps_end
     if timestamps_end != None:
+    if timestamps_end is not None:
         if len(timestamps_end) != len(timestamps):
             raise ValueError ("len(timestamps_end) != len(timestamps)")
+            raise ValueError("len(timestamps_end) != len(timestamps)")
     else:
         timestamps_end = [t - 1 for t in timestamps[1:] ] + [ max_timestamp ]
+        timestamps_end = [t - 1 for t in timestamps[1:]] + [_max_timestamp]
     regions = zip(timestamps, timestamps_end)
+    regions = list(zip(timestamps, timestamps_end))
     #print regions
     source_base_name, source_ext = os.path.splitext(os.path.basename(source_file))
     if output_dir != None:
+    source_base_name, _ = os.path.splitext(os.path.basename(source_file))
+    if output_dir is not None:
         if not os.path.isdir(output_dir):
             os.makedirs(output_dir)
 …
     def new_sink_name(source_base_name, timestamp, samplerate):
+        """ create a sink based on a timestamp in samples, converted in seconds """
         timestamp_seconds = timestamp / float(samplerate)
         return source_base_name + "_%011.6f" % timestamp_seconds + '.wav'
     # reopen source file
     s = source(source_file, samplerate, hopsize)
     samplerate = s.get_samplerate()
+    # open source file
+    _source = source(source_file, samplerate, hopsize)
+    samplerate = _source.samplerate
     total_frames = 0
 …
     while True:
         # get hopsize new samples from source
         vec, read = s.do_multi()
+        vec, read = _source.do_multi()
         # if the total number of frames read will exceed the next region start
         if len(regions) and total_frames + read >= regions[0][0]:
 …
             new_sink_path = new_sink_name(source_base_name, start_stamp, samplerate)
             # create its sink
             g = sink(new_sink_path, samplerate, s.channels)
+            _sink = sink(new_sink_path, samplerate, _source.channels)
             # create a dictionary containing all this
             new_slice = {'start_stamp': start_stamp, 'end_stamp': end_stamp, 'sink': g}
+            new_slice = {'start_stamp': start_stamp, 'end_stamp': end_stamp, 'sink': _sink}
             # append the dictionary to the current list of slices
             slices.append(new_slice)
 …
             start_stamp = current_slice['start_stamp']
             end_stamp = current_slice['end_stamp']
             g = current_slice['sink']
+            _sink = current_slice['sink']
             # sample index to start writing from new source vector
             start = max(start_stamp - total_frames, 0)
 …
                 if remaining > start:
                     # write remaining samples from current region
                     g.do_multi(vec[:,start:remaining], remaining - start)
+                    _sink.do_multi(vec[:, start:remaining], remaining - start)
                     #print "closing region", "remaining", remaining
                     # close this file
                     g.close()
+                    _sink.close()
             elif read > start:
                 # write all the samples
                 g.do_multi(vec[:,start:read], read - start)
+                _sink.do_multi(vec[:, start:read], read - start)
         total_frames += read
+        if read < hopsize: break
+        if read < hopsize:
+            break

python/scripts/aubiocut

-                      r60fc05b
+                      rf264b17
             options.source_file = args[0]
         else:
             print "no file name given\n", usage
+            print ("no file name given\n" + usage)
             sys.exit(1)
     return options, args
 …
         if o(samples):
             timestamps.append (o.get_last())
             if options.verbose: print "%.4f" % o.get_last_s()
+            if options.verbose: print ("%.4f" % o.get_last_s())
         total_frames += read
         if read < hopsize: break
 …
         timestamps_end = None
         if options.cut_until_nslices and options.cut_until_nsamples:
             print "warning: using cut_until_nslices, but cut_until_nsamples is set"
+            print ("warning: using cut_until_nslices, but cut_until_nsamples is set")
         if options.cut_until_nsamples:
             timestamps_end = [t + options.cut_until_nsamples for t in timestamps[1:]]

python/tests/run_all_tests

-                      r60fc05b
+                      rf264b17
 if __name__ == '__main__':
+  import os, sys, unittest
+  def load_test():
+    # get relevant files
+    curdir = os.path.dirname(sys.argv[0])
+    if curdir == '': curdir = '.'
+    files = os.listdir(curdir)
+    modfiles = filter (lambda y: y.endswith('.py'), files)
+    modfiles = filter (lambda f: f.startswith('test_'), modfiles)
+    modfiles = filter (lambda y: not 'beattracking' in y, modfiles)
+    modfiles = filter (lambda y: not 'hist' in y, modfiles)
+    modfiles = filter (lambda y: not 'scale' in y, modfiles)
+    modfiles = filter (lambda y: not 'peakpicker' in y, modfiles)
+    # get module names
+    modnames = map (lambda x: os.path.splitext(x)[0], modfiles)
+    # import them
+    modules = map (__import__, modnames)
+    # create a test suites from the imported module
+    load_from_module = unittest.defaultTestLoader.loadTestsFromModule
+    tests = map(load_from_module, modules)
+    return unittest.TestSuite(tests)
+  unittest.main(defaultTest = 'load_test')
+    import nose2.main
+    nose2.discover()

python/tests/test_aubio.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, run_module_suite
+from unittest import main
+from numpy.testing import TestCase
 class aubiomodule_test_case(TestCase):
   def test_import(self):
     """ try importing aubio """
     import aubio
+    def test_import(self):
+        """ try importing aubio """
+        import aubio
 if __name__ == '__main__':
+  from unittest import main
+  main()
+    main()

python/tests/test_cvec.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, run_module_suite
+from numpy.testing import assert_equal, assert_almost_equal
+from aubio import cvec
+from numpy import array, shape, pi
+from unittest import main
+import numpy as np
+from numpy.testing import TestCase, assert_equal
+from aubio import cvec, fvec, float_type
+wrong_type = 'float32' if float_type == 'float64' else 'float64'
 class aubio_cvec_test_case(TestCase):
 …
     def test_vector_created_with_zeroes(self):
         a = cvec(10)
         shape(a.norm)
         shape(a.phas)
         a.norm[0]
+        assert_equal(a.norm.shape[0], 10 / 2 + 1)
+        assert_equal(a.phas.shape[0], 10 / 2 + 1)
+        _ = a.norm[0]
         assert_equal(a.norm, 0.)
         assert_equal(a.phas, 0.)
 …
     def test_assign_cvec_phas_slice(self):
         spec = cvec(1024)
         spec.phas[39:-1] = -pi
+        spec.phas[39:-1] = -np.pi
         assert_equal(spec.phas[0:39], 0)
         assert_equal(spec.phas[39:-1], -pi)
+        assert_equal(spec.phas[39:-1], -np.pi)
         assert_equal(spec.norm, 0)
+    def test_assign_cvec_with_other_cvec(self):
+        """ check dest cvec is still reachable after source was deleted """
+        spec = cvec(1024)
+        a = np.random.rand(1024//2+1).astype(float_type)
+        b = np.random.rand(1024//2+1).astype(float_type)
+        spec.norm = a
+        spec.phas = b
+        new_spec = spec
+        del spec
+        assert_equal(a, new_spec.norm)
+        assert_equal(b, new_spec.phas)
+        assert_equal(id(a), id(new_spec.norm))
+        assert_equal(id(b), id(new_spec.phas))
+    def test_pass_to_numpy(self):
+        spec = cvec(1024)
+        norm = spec.norm
+        phas = spec.phas
+        del spec
+        new_spec = cvec(1024)
+        new_spec.norm = norm
+        new_spec.phas = phas
+        assert_equal(norm, new_spec.norm)
+        assert_equal(phas, new_spec.phas)
+        assert_equal(id(norm), id(new_spec.norm))
+        assert_equal(id(phas), id(new_spec.phas))
+        del norm
+        del phas
+        assert_equal(new_spec.norm, 0.)
+        assert_equal(new_spec.phas, 0.)
+        del new_spec
+    def test_assign_norm_too_large(self):
+        a = cvec(512)
+        b = fvec(512//2+1 + 4)
+        with self.assertRaises(ValueError):
+            a.norm = b
+    def test_assign_norm_too_small(self):
+        a = cvec(512)
+        b = fvec(512//2+1 - 4)
+        with self.assertRaises(ValueError):
+            a.norm = b
+    def test_assign_phas_too_large(self):
+        a = cvec(512)
+        b = fvec(512//2+1 + 4)
+        with self.assertRaises(ValueError):
+            a.phas = b
+    def test_assign_phas_too_small(self):
+        a = cvec(512)
+        b = fvec(512//2+1 - 4)
+        with self.assertRaises(ValueError):
+            a.phas = b
+    def test_cvec_repr(self):
+        win_s = 512
+        c = cvec(win_s)
+        expected_repr = "aubio cvec of {:d} elements".format(win_s//2+1)
+        self.assertEqual(repr(c), expected_repr)
+class aubio_cvec_wrong_norm_input(TestCase):
+    def test_wrong_length(self):
+        with self.assertRaises(ValueError):
+            cvec(-1)
+    def test_set_norm_with_scalar(self):
+        a = cvec(512)
+        with self.assertRaises(ValueError):
+            a.norm = 1
+    def test_set_norm_with_scalar_array(self):
+        a = cvec(512)
+        with self.assertRaises(ValueError):
+            a.norm = np.ndarray(1, dtype = 'int')
+    def test_set_norm_with_int_array(self):
+        a = cvec(512)
+        with self.assertRaises(ValueError):
+            a.norm = np.zeros(512//2+1, dtype = 'int')
+    def test_set_norm_with_wrong_float_array(self):
+        a = cvec(512)
+        with self.assertRaises(ValueError):
+            a.norm = np.zeros(512//2+1, dtype = wrong_type)
+    def test_set_norm_with_wrong_2d_array(self):
+        a = cvec(512)
+        with self.assertRaises(ValueError):
+            a.norm = np.zeros((512//2+1, 2), dtype = float_type)
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_fft.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, run_module_suite
+from unittest import main
+from numpy.testing import TestCase
 from numpy.testing import assert_equal, assert_almost_equal
+import numpy as np
 from aubio import fvec, fft, cvec
 from numpy import array, shape
 from math import pi
+from math import pi, floor
+from random import random
 class aubio_fft_test_case(TestCase):
 …
         f = fft (win_s)
         fftgrain = f (timegrain)
+        assert_equal (shape(fftgrain.norm), (win_s/2+1,))
+        assert_equal (shape(fftgrain.phas), (win_s/2+1,))
+        del f
+        assert_equal (fftgrain.norm.shape, (win_s/2+1,))
+        assert_equal (fftgrain.phas.shape, (win_s/2+1,))
     def test_zeros(self):
 …
     def test_impulse(self):
         """ check the transform of one impulse at a random place """
-        from random import random
-        from math import floor
         win_s = 256
         i = floor(random()*win_s)
+        i = int(floor(random()*win_s))
         impulse = pi * random()
         f = fft(win_s)
 …
     def test_impulse_negative(self):
+        """ check the transform of one impulse at a random place """
+        from random import random
+        from math import floor
+        """ check the transform of a negative impulse at a random place """
         win_s = 256
         i = 0
         impulse = -10.
+        i = int(floor(random()*win_s))
+        impulse = -.1
         f = fft(win_s)
         timegrain = fvec(win_s)
+        timegrain[0] = 0
         timegrain[i] = impulse
         fftgrain = f ( timegrain )
         #self.plot_this ( fftgrain.phas )
         assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 6 )
+        assert_almost_equal ( fftgrain.norm, abs(impulse), decimal = 5 )
         if impulse < 0:
             # phase can be pi or -pi, as it is not unwrapped
             assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
+            #assert_almost_equal ( abs(fftgrain.phas[1:-1]) , pi, decimal = 6 )
             assert_almost_equal ( fftgrain.phas[0], pi, decimal = 6)
             assert_almost_equal ( fftgrain.phas[-1], pi, decimal = 6)
+            assert_almost_equal ( np.fmod(fftgrain.phas[-1], pi), 0, decimal = 6)
         else:
             assert_equal ( fftgrain.phas[1:-1] == 0, True)
             assert_equal ( fftgrain.phas[0] == 0, True)
             assert_equal ( fftgrain.phas[-1] == 0, True)
+            #assert_equal ( fftgrain.phas[1:-1] == 0, True)
+            assert_equal ( fftgrain.phas[0], 0)
+            assert_almost_equal ( np.fmod(fftgrain.phas[-1], pi), 0, decimal = 6)
         # now check the resynthesis
         synthgrain = f.rdo ( fftgrain )
 …
         """ check running fft.rdo before fft.do works """
         win_s = 1024
-        impulse = pi
         f = fft(win_s)
         fftgrain = cvec(win_s)
 …
         show ()
+    def test_local_fftgrain(self):
+        """ check aubio.fft() result can be accessed after deletion """
+        def compute_grain(impulse):
+            win_s = 1024
+            timegrain = fvec(win_s)
+            timegrain[0] = impulse
+            f = fft(win_s)
+            fftgrain = f ( timegrain )
+            return fftgrain
+        impulse = pi
+        fftgrain = compute_grain(impulse)
+        assert_equal ( fftgrain.phas[0], 0)
+        assert_almost_equal ( fftgrain.phas[1], 0)
+        assert_almost_equal ( fftgrain.norm[0], impulse, decimal = 6 )
+    def test_local_reconstruct(self):
+        """ check aubio.fft.rdo() result can be accessed after deletion """
+        def compute_grain(impulse):
+            win_s = 1024
+            timegrain = fvec(win_s)
+            timegrain[0] = impulse
+            f = fft(win_s)
+            fftgrain = f ( timegrain )
+            r = f.rdo(fftgrain)
+            return r
+        impulse = pi
+        r = compute_grain(impulse)
+        assert_almost_equal ( r[0], impulse, decimal = 6)
+        assert_almost_equal ( r[1:], 0)
+    def test_large_input_timegrain(self):
+        win_s = 1024
+        f = fft(win_s)
+        t = fvec(win_s + 1)
+        with self.assertRaises(ValueError):
+            f(t)
+    def test_small_input_timegrain(self):
+        win_s = 1024
+        f = fft(win_s)
+        t = fvec(1)
+        with self.assertRaises(ValueError):
+            f(t)
+    def test_large_input_fftgrain(self):
+        win_s = 1024
+        f = fft(win_s)
+        s = cvec(win_s + 5)
+        with self.assertRaises(ValueError):
+            f.rdo(s)
+    def test_small_input_fftgrain(self):
+        win_s = 1024
+        f = fft(win_s)
+        s = cvec(16)
+        with self.assertRaises(ValueError):
+            f.rdo(s)
+class aubio_fft_wrong_params(TestCase):
+    def test_wrong_buf_size(self):
+        win_s = -1
+        with self.assertRaises(ValueError):
+            fft(win_s)
+    def test_buf_size_not_power_of_two(self):
+        # when compiled with fftw3, aubio supports non power of two fft sizes
+        win_s = 320
+        try:
+            with self.assertRaises(RuntimeError):
+                fft(win_s)
+        except AssertionError:
+            self.skipTest('creating aubio.fft with size %d did not fail' % win_s)
+    def test_buf_size_too_small(self):
+        win_s = 1
+        with self.assertRaises(RuntimeError):
+            fft(win_s)
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_filter.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from unittest import main
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from aubio import fvec, digital_filter
-from numpy import array
 from utils import array_from_text_file
 class aubio_filter_test_case(TestCase):
+  def test_members(self):
+    f = digital_filter()
+    assert_equal (f.order, 7)
+    f = digital_filter(5)
+    assert_equal (f.order, 5)
+    f(fvec())
+  def test_cweighting_error(self):
+    f = digital_filter (2)
+    self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
+    f = digital_filter (8)
+    self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
+    f = digital_filter (5)
+    self.assertRaises ( ValueError, f.set_c_weighting, 4000 )
+    f = digital_filter (5)
+    self.assertRaises ( ValueError, f.set_c_weighting, 193000 )
+    f = digital_filter (7)
+    self.assertRaises ( ValueError, f.set_a_weighting, 193000 )
+    f = digital_filter (5)
+    self.assertRaises ( ValueError, f.set_a_weighting, 192000 )
+    def test_members(self):
+        f = digital_filter()
+        assert_equal (f.order, 7)
+        f = digital_filter(5)
+        assert_equal (f.order, 5)
+        f(fvec())
+  def test_c_weighting(self):
+    expected = array_from_text_file('c_weighting_test_simple.expected')
+    f = digital_filter(5)
+    f.set_c_weighting(44100)
+    v = fvec(32)
+    v[12] = .5
+    u = f(v)
+    assert_almost_equal (expected[1], u)
+    def test_cweighting_error(self):
+        f = digital_filter (2)
+        self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
+        f = digital_filter (8)
+        self.assertRaises ( ValueError, f.set_c_weighting, 44100 )
+        f = digital_filter (5)
+        self.assertRaises ( ValueError, f.set_c_weighting, 4000 )
+        f = digital_filter (5)
+        self.assertRaises ( ValueError, f.set_c_weighting, 193000 )
+        f = digital_filter (7)
+        self.assertRaises ( ValueError, f.set_a_weighting, 193000 )
+        f = digital_filter (5)
+        self.assertRaises ( ValueError, f.set_a_weighting, 192000 )
   def test_c_weighting_8000(self):
     expected = array_from_text_file('c_weighting_test_simple_8000.expected')
     f = digital_filter(5)
     f.set_c_weighting(8000)
     v = fvec(32)
     v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
+    def test_c_weighting(self):
+        expected = array_from_text_file('c_weighting_test_simple.expected')
+        f = digital_filter(5)
+        f.set_c_weighting(44100)
+        v = fvec(32)
+        v[12] = .5
+        u = f(v)
+        assert_almost_equal (expected[1], u)
   def test_a_weighting(self):
     expected = array_from_text_file('a_weighting_test_simple.expected')
     f = digital_filter(7)
     f.set_a_weighting(44100)
     v = fvec(32)
     v[12] = .5
     u = f(v)
     assert_almost_equal (expected[1], u)
+    def test_c_weighting_8000(self):
+        expected = array_from_text_file('c_weighting_test_simple_8000.expected')
+        f = digital_filter(5)
+        f.set_c_weighting(8000)
+        v = fvec(32)
+        v[12] = .5
+        u = f(v)
+        assert_almost_equal (expected[1], u)
+  def test_a_weighting_parted(self):
+    expected = array_from_text_file('a_weighting_test_simple.expected')
+    f = digital_filter(7)
+    f.set_a_weighting(44100)
+    v = fvec(16)
+    v[12] = .5
+    u = f(v)
+    assert_almost_equal (expected[1][:16], u)
+    # one more time
+    v = fvec(16)
+    u = f(v)
+    assert_almost_equal (expected[1][16:], u)
+    def test_a_weighting(self):
+        expected = array_from_text_file('a_weighting_test_simple.expected')
+        f = digital_filter(7)
+        f.set_a_weighting(44100)
+        v = fvec(32)
+        v[12] = .5
+        u = f(v)
+        assert_almost_equal (expected[1], u)
+    def test_a_weighting_parted(self):
+        expected = array_from_text_file('a_weighting_test_simple.expected')
+        f = digital_filter(7)
+        f.set_a_weighting(44100)
+        v = fvec(16)
+        v[12] = .5
+        u = f(v)
+        assert_almost_equal (expected[1][:16], u)
+        # one more time
+        v = fvec(16)
+        u = f(v)
+        assert_almost_equal (expected[1][16:], u)
+    def test_set_biquad(self):
+        f = digital_filter(3)
+        f.set_biquad(0., 0., 0, 0., 0.)
+    def test_set_biquad_wrong_order(self):
+        f = digital_filter(4)
+        with self.assertRaises(ValueError):
+            f.set_biquad(0., 0., 0, 0., 0.)
+class aubio_filter_wrong_params(TestCase):
+    def test_negative_order(self):
+        with self.assertRaises(ValueError):
+            digital_filter(-1)
 if __name__ == '__main__':
+  from unittest import main
+  main()
+    main()

python/tests/test_filterbank.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, run_module_suite
+from unittest import main
+from numpy.testing import TestCase
 from numpy.testing import assert_equal, assert_almost_equal
+from numpy import random
+from math import pi
+from numpy import array
+from aubio import cvec, filterbank
+import numpy as np
+from aubio import cvec, filterbank, float_type
 from utils import array_from_text_file
 class aubio_filterbank_test_case(TestCase):
   def test_members(self):
     f = filterbank(40, 512)
     assert_equal ([f.n_filters, f.win_s], [40, 512])
+    def test_members(self):
+        f = filterbank(40, 512)
+        assert_equal ([f.n_filters, f.win_s], [40, 512])
   def test_set_coeffs(self):
     f = filterbank(40, 512)
     r = random.random([40, 512 / 2 + 1]).astype('float32')
     f.set_coeffs(r)
     assert_equal (r, f.get_coeffs())
+    def test_set_coeffs(self):
+        f = filterbank(40, 512)
+        r = np.random.random([40, int(512 / 2) + 1]).astype(float_type)
+        f.set_coeffs(r)
+        assert_equal (r, f.get_coeffs())
   def test_phase(self):
     f = filterbank(40, 512)
     c = cvec(512)
     c.phas[:] = pi
     assert_equal( f(c), 0);
+    def test_phase(self):
+        f = filterbank(40, 512)
+        c = cvec(512)
+        c.phas[:] = np.pi
+        assert_equal( f(c), 0);
   def test_norm(self):
     f = filterbank(40, 512)
     c = cvec(512)
     c.norm[:] = 1
     assert_equal( f(c), 0);
+    def test_norm(self):
+        f = filterbank(40, 512)
+        c = cvec(512)
+        c.norm[:] = 1
+        assert_equal( f(c), 0);
   def test_random_norm(self):
     f = filterbank(40, 512)
     c = cvec(512)
     c.norm[:] = random.random((512 / 2 + 1,)).astype('float32')
     assert_equal( f(c), 0)
+    def test_random_norm(self):
+        f = filterbank(40, 512)
+        c = cvec(512)
+        c.norm[:] = np.random.random((int(512 / 2) + 1,)).astype(float_type)
+        assert_equal( f(c), 0)
+  def test_random_coeffs(self):
+    f = filterbank(40, 512)
+    c = cvec(512)
+    r = random.random([40, 512 / 2 + 1]).astype('float32')
+    r /= r.sum()
+    f.set_coeffs(r)
+    c.norm[:] = random.random((512 / 2 + 1,)).astype('float32')
+    assert_equal ( f(c) < 1., True )
+    assert_equal ( f(c) > 0., True )
+    def test_random_coeffs(self):
+        win_s = 128
+        f = filterbank(40, win_s)
+        c = cvec(win_s)
+        r = np.random.random([40, int(win_s / 2) + 1]).astype(float_type)
+        r /= r.sum()
+        f.set_coeffs(r)
+        c.norm[:] = np.random.random((int(win_s / 2) + 1,)).astype(float_type)
+        assert_equal ( f(c) < 1., True )
+        assert_equal ( f(c) > 0., True )
   def test_mfcc_coeffs(self):
     f = filterbank(40, 512)
     c = cvec(512)
     f.set_mel_coeffs_slaney(44100)
     c.norm[:] = random.random((512 / 2 + 1,)).astype('float32')
     assert_equal ( f(c) < 1., True )
     assert_equal ( f(c) > 0., True )
+    def test_mfcc_coeffs(self):
+        f = filterbank(40, 512)
+        c = cvec(512)
+        f.set_mel_coeffs_slaney(44100)
+        c.norm[:] = np.random.random((int(512 / 2) + 1,)).astype(float_type)
+        assert_equal ( f(c) < 1., True )
+        assert_equal ( f(c) > 0., True )
+  def test_mfcc_coeffs_16000(self):
+    expected = array_from_text_file('filterbank_mfcc_16000_512.expected')
+    f = filterbank(40, 512)
+    f.set_mel_coeffs_slaney(16000)
+    assert_almost_equal ( expected, f.get_coeffs() )
+    def test_mfcc_coeffs_16000(self):
+        expected = array_from_text_file('filterbank_mfcc_16000_512.expected')
+        f = filterbank(40, 512)
+        f.set_mel_coeffs_slaney(16000)
+        assert_almost_equal ( expected, f.get_coeffs() )
+class aubio_filterbank_wrong_values(TestCase):
+    def test_negative_window(self):
+        self.assertRaises(ValueError, filterbank, 40, -20)
+    def test_negative_filters(self):
+        self.assertRaises(ValueError, filterbank, -40, 1024)
+    def test_filterbank_long_cvec(self):
+        f = filterbank(40, 512)
+        with self.assertRaises(ValueError):
+            f(cvec(1024))
+    def test_filterbank_short_cvec(self):
+        f = filterbank(40, 512)
+        with self.assertRaises(ValueError):
+            f(cvec(256))
 if __name__ == '__main__':
+  from unittest import main
+  main()
+    main()

python/tests/test_filterbank_mel.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, run_module_suite
+from unittest import main
+from numpy.testing import TestCase
 from numpy.testing import assert_equal, assert_almost_equal
 from numpy import array, shape
 from aubio import cvec, filterbank
+from aubio import cvec, filterbank, float_type
 class aubio_filterbank_mel_test_case(TestCase):
   def test_slaney(self):
     f = filterbank(40, 512)
     f.set_mel_coeffs_slaney(16000)
     a = f.get_coeffs()
     assert_equal(shape (a), (40, 512/2 + 1) )
+    def test_slaney(self):
+        f = filterbank(40, 512)
+        f.set_mel_coeffs_slaney(16000)
+        a = f.get_coeffs()
+        assert_equal(shape (a), (40, 512/2 + 1) )
   def test_other_slaney(self):
     f = filterbank(40, 512*2)
     f.set_mel_coeffs_slaney(44100)
     a = f.get_coeffs()
     #print "sum is", sum(sum(a))
     for win_s in [256, 512, 1024, 2048, 4096]:
       f = filterbank(40, win_s)
       f.set_mel_coeffs_slaney(320000)
       a = f.get_coeffs()
       #print "sum is", sum(sum(a))
+    def test_other_slaney(self):
+        f = filterbank(40, 512*2)
+        f.set_mel_coeffs_slaney(44100)
+        _ = f.get_coeffs()
+        #print "sum is", sum(sum(a))
+        for win_s in [256, 512, 1024, 2048, 4096]:
+            f = filterbank(40, win_s)
+            f.set_mel_coeffs_slaney(32000)
+            _ = f.get_coeffs()
+            #print "sum is", sum(sum(a))
   def test_triangle_freqs_zeros(self):
     f = filterbank(9, 1024)
     freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
     freqs = array(freq_list, dtype = 'float32')
     f.set_triangle_bands(freqs, 48000)
     f.get_coeffs().T
     assert_equal ( f(cvec(1024)), 0)
+    def test_triangle_freqs_zeros(self):
+        f = filterbank(9, 1024)
+        freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
+        freqs = array(freq_list, dtype = float_type)
+        f.set_triangle_bands(freqs, 48000)
+        _ = f.get_coeffs().T
+        assert_equal ( f(cvec(1024)), 0)
   def test_triangle_freqs_ones(self):
     f = filterbank(9, 1024)
     freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
     freqs = array(freq_list, dtype = 'float32')
     f.set_triangle_bands(freqs, 48000)
     f.get_coeffs().T
     spec = cvec(1024)
     spec.norm[:] = 1
     assert_almost_equal ( f(spec),
             [ 0.02070313,  0.02138672,  0.02127604,  0.02135417,
 .02133301, 0.02133301,  0.02133311,  0.02133334,  0.02133345])
+    def test_triangle_freqs_ones(self):
+        f = filterbank(9, 1024)
+        freq_list = [40, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 15000, 24000]
+        freqs = array(freq_list, dtype = float_type)
+        f.set_triangle_bands(freqs, 48000)
+        _ = f.get_coeffs().T
+        spec = cvec(1024)
+        spec.norm[:] = 1
+        assert_almost_equal ( f(spec),
+                [ 0.02070313, 0.02138672, 0.02127604, 0.02135417,
+.02133301, 0.02133301, 0.02133311, 0.02133334, 0.02133345])
 if __name__ == '__main__':
+  from unittest import main
+  main()
+    main()

python/tests/test_fvec.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, run_module_suite
+from numpy.testing import assert_equal, assert_almost_equal
+from unittest import main
+import numpy as np
+from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from aubio import fvec, zero_crossing_rate, alpha_norm, min_removal
+from numpy import array, shape
+from aubio import float_type
+wrong_type = 'float32' if float_type == 'float64' else 'float64'
 default_size = 512
 …
     def test_vector_created_with_zeroes(self):
         a = fvec(10)
         assert a.dtype == 'float32'
+        assert a.dtype == float_type
         assert a.shape == (10,)
         assert_equal (a, 0)
+        assert_equal(a, 0)
     def test_vector_create_with_list(self):
         a = fvec([0,1,2,3])
         assert a.dtype == 'float32'
+        a = fvec([0, 1, 2, 3])
+        assert a.dtype == float_type
         assert a.shape == (4,)
         assert_equal (range(4), a)
+        assert_equal(list(range(4)), a)
     def test_vector_assign_element(self):
 …
     def test_vector(self):
         a = fvec()
+        a, len(a) #a.length
+        a[0]
+        array(a)
+        len(a)
+        _ = a[0]
+        np.array(a)
+        a = fvec(1)
         a = fvec(10)
+        a = fvec(1)
+        a.T
+        array(a).T
+        a = range(len(a))
+        _ = a.T
+    def test_wrong_values(self):
+        self.assertRaises (ValueError, fvec, -10)
+class aubio_fvec_wrong_values(TestCase):
+    def test_negative_length(self):
+        """ test creating fvec with negative length fails (pure python) """
+        self.assertRaises(ValueError, fvec, -10)
+    def test_zero_length(self):
+        """ test creating fvec with zero length fails (pure python) """
+        self.assertRaises(ValueError, fvec, 0)
+    def test_out_of_bound(self):
+        """ test assiging fvec out of bounds fails (pure python) """
         a = fvec(2)
         self.assertRaises (IndexError, a.__getitem__, 3)
         self.assertRaises (IndexError, a.__getitem__, 2)
+        self.assertRaises(IndexError, a.__getitem__, 3)
+        self.assertRaises(IndexError, a.__getitem__, 2)
+    def test_alpha_norm_of_fvec(self):
+        a = fvec(2)
+        self.assertEquals (alpha_norm(a, 1), 0)
+        a[0] = 1
+        self.assertEquals (alpha_norm(a, 1), 0.5)
+        a[1] = 1
+        self.assertEquals (alpha_norm(a, 1), 1)
+        a = array([0, 1], dtype='float32')
+        from math import sqrt
+        assert_almost_equal (alpha_norm(a, 2), sqrt(2)/2.)
+class aubio_wrong_fvec_input(TestCase):
+    """ uses min_removal to test PyAubio_IsValidVector """
     def test_alpha_norm_of_none(self):
         self.assertRaises (ValueError, alpha_norm, None, 1)
+    def test_no_input(self):
+        self.assertRaises(TypeError, min_removal)
+    def test_alpha_norm_of_array_of_float32(self):
+        # check scalar fails
+        a = array(1, dtype = 'float32')
+        self.assertRaises (ValueError, alpha_norm, a, 1)
+        # check 2d array fails
+        a = array([[2],[4]], dtype = 'float32')
+        self.assertRaises (ValueError, alpha_norm, a, 1)
+        # check 1d array
+        a = array(range(10), dtype = 'float32')
+        self.assertEquals (alpha_norm(a, 1), 4.5)
+    def test_none(self):
+        self.assertRaises(ValueError, min_removal, None)
+    def test_alpha_norm_of_array_of_int(self):
+        a = array(1, dtype = 'int')
+        self.assertRaises (ValueError, alpha_norm, a, 1)
+        a = array([[[1,2],[3,4]]], dtype = 'int')
+        self.assertRaises (ValueError, alpha_norm, a, 1)
+        a = array(range(10), dtype = 'int')
+        self.assertRaises (ValueError, alpha_norm, a, 1)
+    def test_wrong_scalar(self):
+        a = np.array(10, dtype=float_type)
+        self.assertRaises(ValueError, min_removal, a)
+    def test_alpha_norm_of_array_of_string (self):
+        a = "hello"
+        self.assertRaises (ValueError, alpha_norm, a, 1)
+    def test_wrong_dimensions(self):
+        a = np.array([[[1, 2], [3, 4]]], dtype=float_type)
+        self.assertRaises(ValueError, min_removal, a)
+    def test_wrong_array_size(self):
+        x = np.array([], dtype=float_type)
+        self.assertRaises(ValueError, min_removal, x)
+    def test_wrong_type(self):
+        a = np.zeros(10, dtype=wrong_type)
+        self.assertRaises(ValueError, min_removal, a)
+    def test_wrong_list_input(self):
+        self.assertRaises(ValueError, min_removal, [0., 1.])
+    def test_good_input(self):
+        a = np.zeros(10, dtype=float_type)
+        assert_equal(np.zeros(10, dtype=float_type), min_removal(a))
+class aubio_alpha_norm(TestCase):
+    def test_alpha_norm_of_random(self):
+        x = np.random.rand(1024).astype(float_type)
+        alpha = np.random.rand() * 5.
+        x_alpha_norm = (np.sum(np.abs(x)**alpha)/len(x))**(1/alpha)
+        assert_almost_equal(alpha_norm(x, alpha), x_alpha_norm, decimal = 5)
+class aubio_zero_crossing_rate_test(TestCase):
     def test_zero_crossing_rate(self):
+        a = array([0,1,-1], dtype='float32')
+        assert_almost_equal (zero_crossing_rate(a), 1./3. )
+        a = array([0.]*100, dtype='float32')
+        self.assertEquals (zero_crossing_rate(a), 0 )
+        a = array([-1.]*100, dtype='float32')
+        self.assertEquals (zero_crossing_rate(a), 0 )
+        a = array([1.]*100, dtype='float32')
+        self.assertEquals (zero_crossing_rate(a), 0 )
+        a = np.array([0, 1, -1], dtype=float_type)
+        assert_almost_equal(zero_crossing_rate(a), 1./3.)
     def test_alpha_norm_of_array_of_float64(self):
         # check scalar fail
         a = array(1, dtype = 'float64')
+        self.assertRaises (ValueError, alpha_norm, a, 1)
         # check 3d array fail
         a = array([[[1,2],[3,4]]], dtype = 'float64')
         self.assertRaises (ValueError, alpha_norm, a, 1)
+        # check float64 1d array fail
         a = array(range(10), dtype = 'float64')
         self.assertRaises (ValueError, alpha_norm, a, 1)
         # check float64 2d array fail
+        a = array([range(10), range(10)], dtype = 'float64')
+        self.assertRaises (ValueError, alpha_norm, a, 1)
+    def test_zero_crossing_rate_zeros(self):
+        a = np.zeros(100, dtype=float_type)
+        self.assertEqual(zero_crossing_rate(a), 0)
+    def test_zero_crossing_rate_minus_ones(self):
+        a = np.ones(100, dtype=float_type)
+        self.assertEqual(zero_crossing_rate(a), 0)
+    def test_zero_crossing_rate_plus_ones(self):
+        a = np.ones(100, dtype=float_type)
+        self.assertEqual(zero_crossing_rate(a), 0)
+class aubio_fvec_min_removal(TestCase):
     def test_fvec_min_removal_of_array(self):
         a = array([20,1,19], dtype='float32')
+        a = np.array([20, 1, 19], dtype=float_type)
         b = min_removal(a)
+        assert_equal (array(b), [19, 0, 18])
+        assert_equal (b, [19, 0, 18])
+        assert_equal (a, b)
+        a[0] = 0
+        assert_equal (a, b)
+        assert_equal(b, [19, 0, 18])
+    def test_fvec_min_removal_of_array_float64(self):
+        a = array([20,1,19], dtype='float64')
+        self.assertRaises (ValueError, min_removal, a)
+class aubio_fvec_test_memory(TestCase):
+    def test_fvec_min_removal_of_fvec(self):
+        a = fvec(3)
+        a = array([20, 1, 19], dtype = 'float32')
+        b = min_removal(a)
+        assert_equal (array(b), [19, 0, 18])
+        assert_equal (b, [19, 0, 18])
+        assert_equal (a, b)
+    def test_pass_to_numpy(self):
+        a = fvec(10)
+        a[:] = 1.
+        b = a
+        del a
+        assert_equal(b, 1.)
+        c = fvec(10)
+        c = b
+        del b
+        assert_equal(c, 1.)
+        del c
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_mathutils.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from unittest import main
 from numpy.testing import TestCase, assert_equal
 from numpy import array, arange, isnan, isinf
 …
         unwrap2pi(int(23))
         unwrap2pi(float(23.))
         unwrap2pi(long(23.))
+        unwrap2pi(int(23.))
         unwrap2pi(arange(10))
         unwrap2pi(arange(10).astype("int"))
 …
         unwrap2pi(a)
         a = pi/100. * arange(-600,600).astype("float")
         b = unwrap2pi (a)
+        unwrap2pi(a)
         #print zip(a, b)
+        try:
+            print unwrap2pi(["23.","24.",25.])
+        except Exception, e:
+            pass
+    def test_unwrap2pi_fails_on_list(self):
+        with self.assertRaises((TypeError, NotImplementedError)):
+            unwrap2pi(["23.","24.",25.])
     def test_unwrap2pi_takes_fvec(self):
 …
     def test_freqtomidi(self):
         a = array(range(-20, 50000, 100) + [ -1e32, 1e32 ])
+        a = array(list(range(-20, 50000, 100)) + [ -1e32, 1e32 ])
         b = freqtomidi(a)
         #print zip(a, b)
 …
     def test_miditofreq(self):
         a = range(-30, 200) + [-100000, 10000]
+        a = list(range(-30, 200)) + [-100000, 10000]
         b = miditofreq(a)
         #print zip(a, b)
 …
     def test_miditobin(self):
         a = range(-30, 200) + [-100000, 10000]
         b = [ bintomidi(x, 44100, 512) for x in a ]
+        a = list(range(-30, 200)) + [-100000, 10000]
+        b = [ miditobin(x, 44100, 512) for x in a ]
         #print zip(a, b)
         assert_equal ( isnan(array(b)), False )
 …
     def test_bintomidi(self):
         a = range(-100, 512)
+        a = list(range(-100, 512))
         b = [ bintomidi(x, 44100, 512) for x in a ]
         #print zip(a, b)
 …
     def test_freqtobin(self):
         a = range(-20, 50000, 100) + [ -1e32, 1e32 ]
+        a = list(range(-20, 50000, 100)) + [ -1e32, 1e32 ]
         b = [ freqtobin(x, 44100, 512) for x in a ]
         #print zip(a, b)
 …
     def test_bintofreq(self):
         a = range(-20, 148)
+        a = list(range(-20, 148))
         b = [ bintofreq(x, 44100, 512) for x in a ]
         #print zip(a, b)
 …
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_midi2note.py

r60fc05b	rf264b17
28	28	self.assertRaises(ValueError, midi2note, -2)
29	29
30		def test_midi2note_~~negative_valu~~e(self):
	30	def test_midi2note_large(self):
31	31	" fails when passed a value greater than 127 "
32	32	self.assertRaises(ValueError, midi2note, 128)

python/tests/test_musicutils.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from unittest import main
+import numpy as np
 from numpy.testing import TestCase
 from numpy.testing.utils import assert_equal, assert_almost_equal
-from numpy import cos, arange
-from math import pi
 from aubio import window, level_lin, db_spl, silence_detection, level_detection
+from aubio import fvec
+from aubio import fvec, float_type
 class aubio_window(TestCase):
 …
     def test_fail_name_not_string(self):
         try:
+        with self.assertRaises(TypeError):
             window(10, 1024)
-        except ValueError, e:
-            pass
-        else:
-            self.fail('non-string window type does not raise a ValueError')
     def test_fail_size_not_int(self):
         try:
+        with self.assertRaises(TypeError):
             window("default", "default")
-        except ValueError, e:
-            pass
-        else:
-            self.fail('non-integer window length does not raise a ValueError')
     def test_compute_hanning_1024(self):
         size = 1024
         aubio_window = window("hanning", size)
         numpy_window = .5 - .5 * cos(2. * pi * arange(size) / size)
+        numpy_window = .5 - .5 * np.cos(2. * np.pi * np.arange(size) / size)
         assert_almost_equal(aubio_window, numpy_window)
 …
     def test_fail_not_fvec(self):
         try:
+        with self.assertRaises(ValueError):
             level_lin("default")
-        except ValueError, e:
-            pass
-        else:
-            self.fail('non-number input phase does not raise a TypeError')
     def test_zeros_is_zeros(self):
 …
     def test_minus_ones_is_one(self):
+        from numpy import ones
+        assert_equal(level_lin(-ones(1024, dtype="float32")), 1.)
+        assert_equal(level_lin(-np.ones(1024, dtype = float_type)), 1.)
 class aubio_db_spl(TestCase):
 …
     def test_fail_not_fvec(self):
         try:
+        with self.assertRaises(ValueError):
             db_spl("default")
-        except ValueError, e:
-            pass
-        else:
-            self.fail('non-number input phase does not raise a TypeError')
     def test_zeros_is_inf(self):
+        from math import isinf
+        assert isinf(db_spl(fvec(1024)))
+        assert np.isinf(db_spl(fvec(1024)))
     def test_minus_ones_is_zero(self):
+        from numpy import ones
+        assert_equal(db_spl(-ones(1024, dtype="float32")), 0.)
+        assert_equal(db_spl(-np.ones(1024, dtype = float_type)), 0.)
 class aubio_silence_detection(TestCase):
 …
     def test_fail_not_fvec(self):
         try:
+        with self.assertRaises(ValueError):
             silence_detection("default", -70)
-        except ValueError, e:
-            pass
-        else:
-            self.fail('non-number input phase does not raise a TypeError')
     def test_zeros_is_one(self):
-        from math import isinf
         assert silence_detection(fvec(1024), -70) == 1
     def test_minus_ones_is_zero(self):
         from numpy import ones
         assert silence_detection(ones(1024, dtype="float32"), -70) == 0
+        assert silence_detection(ones(1024, dtype = float_type), -70) == 0
 class aubio_level_detection(TestCase):
 …
     def test_fail_not_fvec(self):
         try:
+        with self.assertRaises(ValueError):
             level_detection("default", -70)
-        except ValueError, e:
-            pass
-        else:
-            self.fail('non-number input phase does not raise a TypeError')
     def test_zeros_is_one(self):
-        from math import isinf
         assert level_detection(fvec(1024), -70) == 1
     def test_minus_ones_is_zero(self):
         from numpy import ones
         assert level_detection(ones(1024, dtype="float32"), -70) == 0
+        assert level_detection(ones(1024, dtype = float_type), -70) == 0
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_note2midi.py

-                      r60fc05b
+                      rf264b17
 # -*- coding: utf-8 -*-
+from aubio import note2midi
+from __future__ import unicode_literals
+from aubio import note2midi, freq2note
 import unittest
 …
         ( 'A#4', 70 ),
         ( 'Bb4', 70 ),
         ( u'B♭4', 70 ),
+        ( 'B♭4', 70 ),
         ( 'G8', 115 ),
         ( u'G♯8', 116 ),
+        ( 'G♯8', 116 ),
         ( 'G9', 127 ),
         ( u'G\udd2a2', 45 ),
         ( u'B\ufffd2', 45 ),
         ( u'A♮2', 45 ),
+        ( 'G\udd2a2', 45 ),
+        ( 'B\ufffd2', 45 ),
+        ( 'A♮2', 45 ),
+        )
 …
     def test_note2midi_out_of_range(self):
         " fails when passed a out of range note"
+        " fails when passed a note out of range"
         self.assertRaises(ValueError, note2midi, 'A9')
+    def test_note2midi_wrong_note_name(self):
+        " fails when passed a note with a wrong name"
+        self.assertRaises(ValueError, note2midi, 'W9')
+    def test_note2midi_low_octave(self):
+        " fails when passed a note with a too low octave"
+        self.assertRaises(ValueError, note2midi, 'C-9')
     def test_note2midi_wrong_data_type(self):
 …
         self.assertRaises(TypeError, note2midi, 123)
+class freq2note_simple_test(unittest.TestCase):
+    def test_freq2note(self):
+        " make sure freq2note(441) == A4 "
+        self.assertEqual("A4", freq2note(441))
 if __name__ == '__main__':
     unittest.main()

python/tests/test_onset.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
 from numpy.testing import TestCase, run_module_suite
 from numpy.testing import assert_equal, assert_almost_equal
+from unittest import main
+from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from aubio import onset
 …
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_phasevoc.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, assert_equal, assert_almost_equal
+from aubio import fvec, cvec, pvoc
+from numpy import array, shape
+from numpy.random import random
+from numpy.testing import TestCase, assert_equal, assert_array_less
+from aubio import fvec, cvec, pvoc, float_type
+from nose2 import main
+from nose2.tools import params
+import numpy as np
+precision = 6
+if float_type == 'float32':
+    max_sq_error = 1.e-12
+else:
+    max_sq_error = 1.e-29
+def create_sine(hop_s, freq, samplerate):
+    t = np.arange(hop_s).astype(float_type)
+    return np.sin( 2. * np.pi * freq * t / float(samplerate))
+def create_noise(hop_s):
+    return np.random.rand(hop_s).astype(float_type) * 2. - 1.
 class aubio_pvoc_test_case(TestCase):
 …
         f = pvoc (win_s, hop_s)
         t = fvec (hop_s)
         for time in range( 4 * win_s / hop_s ):
+        for _ in range( int ( 4 * win_s / hop_s ) ):
             s = f(t)
             r = f.rdo(s)
             assert_equal ( array(t), 0)
             assert_equal ( s.norm, 0)
             assert_equal ( s.phas, 0)
             assert_equal ( r, 0)
+            assert_equal ( t, 0.)
+            assert_equal ( s.norm, 0.)
+            assert_equal ( s.phas, 0.)
+            assert_equal ( r, 0.)
+    def test_resynth_two_steps(self):
+        """ check the resynthesis of steps is correct with 50% overlap """
+        hop_s = 512
+        buf_s = hop_s * 2
+    @params(
+            ( 256, 8),
+            ( 256, 4),
+            ( 256, 2),
+            ( 512, 8),
+            ( 512, 4),
+            ( 512, 2),
+            #( 129, 2),
+            #( 320, 4),
+            #(  13, 8),
+            (1024, 8),
+            (1024, 4),
+            (1024, 2),
+            (2048, 8),
+            (2048, 4),
+            (2048, 2),
+            (4096, 8),
+            (4096, 4),
+            (4096, 2),
+            (8192, 8),
+            (8192, 4),
+            (8192, 2),
+            )
+    def test_resynth_steps_noise(self, hop_s, ratio):
+        """ check the resynthesis of a random signal is correct """
+        sigin = create_noise(hop_s)
+        self.reconstruction(sigin, hop_s, ratio)
+    @params(
+            (44100,  256, 8,   441),
+            (44100,  256, 4,  1203),
+            (44100,  256, 2,  3045),
+            (44100,  512, 8,   445),
+            (44100,  512, 4,   445),
+            (44100,  512, 2,   445),
+            (44100, 1024, 8,   445),
+            (44100, 1024, 4,   445),
+            (44100, 1024, 2,   445),
+            ( 8000, 1024, 2,   445),
+            (22050, 1024, 2,   445),
+            (22050,  256, 8,   445),
+            (96000, 1024, 8, 47000),
+            (96000, 1024, 8,    20),
+            )
+    def test_resynth_steps_sine(self, samplerate, hop_s, ratio, freq):
+        """ check the resynthesis of a sine is correct """
+        sigin = create_sine(hop_s, freq, samplerate)
+        self.reconstruction(sigin, hop_s, ratio)
+    def reconstruction(self, sigin, hop_s, ratio):
+        buf_s = hop_s * ratio
         f = pvoc(buf_s, hop_s)
-        sigin = fvec(hop_s)
         zeros = fvec(hop_s)
+        # negative step
+        sigin[20:50] = -.1
+        # positive step
+        sigin[100:200] = .1
+        s1 = f(sigin)
+        r1 = f.rdo(s1)
+        s2 = f(zeros)
+        r2 = f.rdo(s2)
+        #self.plot_this ( s2.norm.T )
+        assert_almost_equal ( r2, sigin, decimal = precision )
+    def test_resynth_three_steps(self):
+        """ check the resynthesis of steps is correct with 25% overlap """
+        hop_s = 16
+        buf_s = hop_s * 4
+        sigin = fvec(hop_s)
+        zeros = fvec(hop_s)
+        f = pvoc(buf_s, hop_s)
+        for i in xrange(hop_s):
+            sigin[i] = random() * 2. - 1.
+        t2 = f.rdo( f(sigin) )
+        t2 = f.rdo( f(zeros) )
+        t2 = f.rdo( f(zeros) )
+        t2 = f.rdo( f(zeros) )
+        assert_almost_equal( sigin, t2, decimal = precision )
+    def plot_this( self, this ):
+        from pylab import semilogy, show
+        semilogy ( this )
+        show ()
+        r2 = f.rdo( f(sigin) )
+        for _ in range(1, ratio):
+            r2 = f.rdo( f(zeros) )
+        # compute square errors
+        sq_error = (r2 - sigin)**2
+        # make sure all square errors are less than desired precision
+        assert_array_less(sq_error, max_sq_error)
+class aubio_pvoc_strange_params(TestCase):
+    def test_win_size_short(self):
+        with self.assertRaises(RuntimeError):
+            pvoc(1, 1)
+    def test_hop_size_long(self):
+        with self.assertRaises(RuntimeError):
+            pvoc(1024, 1025)
+    def test_large_input_timegrain(self):
+        win_s = 1024
+        f = pvoc(win_s)
+        t = fvec(win_s + 1)
+        with self.assertRaises(ValueError):
+            f(t)
+    def test_small_input_timegrain(self):
+        win_s = 1024
+        f = pvoc(win_s)
+        t = fvec(1)
+        with self.assertRaises(ValueError):
+            f(t)
+    def test_large_input_fftgrain(self):
+        win_s = 1024
+        f = pvoc(win_s)
+        s = cvec(win_s + 5)
+        with self.assertRaises(ValueError):
+            f.rdo(s)
+    def test_small_input_fftgrain(self):
+        win_s = 1024
+        f = pvoc(win_s)
+        s = cvec(16)
+        with self.assertRaises(ValueError):
+            f.rdo(s)
+class aubio_pvoc_wrong_params(TestCase):
+    def test_wrong_buf_size(self):
+        win_s = -1
+        with self.assertRaises(ValueError):
+            pvoc(win_s)
+    def test_buf_size_too_small(self):
+        win_s = 1
+        with self.assertRaises(RuntimeError):
+            pvoc(win_s)
+    def test_hop_size_negative(self):
+        win_s = 512
+        hop_s = -2
+        with self.assertRaises(ValueError):
+            pvoc(win_s, hop_s)
+    def test_hop_size_too_small(self):
+        win_s = 1
+        hop_s = 1
+        with self.assertRaises(RuntimeError):
+            pvoc(win_s, hop_s)
+    def test_buf_size_not_power_of_two(self):
+        win_s = 320
+        hop_s = win_s // 2
+        try:
+            with self.assertRaises(RuntimeError):
+                pvoc(win_s, hop_s)
+        except AssertionError:
+            # when compiled with fftw3, aubio supports non power of two fft sizes
+            self.skipTest('creating aubio.pvoc with size %d did not fail' % win_s)
 if __name__ == '__main__':
+  from unittest import main
+  main()
+    main()

python/tests/test_pitch.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from unittest import TestCase
+from numpy.testing import assert_equal, assert_almost_equal
+from numpy import random, sin, arange, mean, median, isnan
+from math import pi
+from aubio import fvec, pitch, freqtomidi
+from unittest import TestCase, main
+from numpy.testing import assert_equal
+from numpy import sin, arange, mean, median, isnan, pi
+from aubio import fvec, pitch, freqtomidi, float_type
 class aubio_pitch_Good_Values(TestCase):
 …
         p = pitch('default', 2048, 512, 32000)
         f = fvec (512)
         for i in xrange(10): assert_equal (p(f), 0.)
+        for _ in range(10): assert_equal (p(f), 0.)
     def test_run_on_ones(self):
 …
         f = fvec (512)
         f[:] = 1
         for i in xrange(10): assert_equal (p(f), 0.)
+        for _ in range(10): assert_equal (p(f), 0.)
 class aubio_pitch_Sinusoid(TestCase):
 …
     def build_sinusoid(self, length, freq, samplerate):
         return sin( 2. * pi * arange(length).astype('float32') * freq / samplerate)
+        return sin( 2. * pi * arange(length).astype(float_type) * freq / samplerate)
     def run_pitch(self, p, input_vec, freq):
-        count = 0
         pitches, errors = [], []
         input_blocks = input_vec.reshape((-1, p.hop_size))
 …
         assert_equal ( isnan(pitches), False )
         # cut the first candidates
         cut = ( p.buf_size - p.hop_size ) / p.hop_size
+        #cut = ( p.buf_size - p.hop_size ) / p.hop_size
         pitches = pitches[2:]
         errors = errors[2:]
 …
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_sink.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, assert_equal, assert_almost_equal
+from nose2 import main
+from nose2.tools import params
+from numpy.testing import TestCase
 from aubio import fvec, source, sink
-from numpy import array
 from utils import list_all_sounds, get_tmp_sink_path, del_tmp_sink_path
 list_of_sounds = list_all_sounds('sounds')
+samplerates = [0, 44100, 8000, 32000]
+hop_sizes = [512, 1024, 64]
 path = None
 many_files = 300 # 256 opened files is too much
+all_params = []
+for soundfile in list_of_sounds:
+    for hop_size in hop_sizes:
+        for samplerate in samplerates:
+            all_params.append((hop_size, samplerate, soundfile))
 class aubio_sink_test_case(TestCase):
+    def setUp(self):
+        if not len(list_of_sounds):
+            self.skipTest('add some sound files in \'python/tests/sounds\'')
     def test_many_sinks(self):
 …
             sink_list.append(g)
             write = 32
             for n in range(200):
+            for _ in range(200):
                 vec = fvec(write)
                 g(vec, write)
 …
         shutil.rmtree(tmpdir)
+    def test_many_sinks_not_closed(self):
+        from tempfile import mkdtemp
+        import os.path
+        import shutil
+        tmpdir = mkdtemp()
+        sink_list = []
+    @params(*all_params)
+    def test_read_and_write(self, hop_size, samplerate, path):
         try:
+            for i in range(many_files):
+                path = os.path.join(tmpdir, 'f-' + str(i) + '.wav')
+                g = sink(path, 0)
+                sink_list.append(g)
+                write = 256
+                for n in range(200):
+                    vec = fvec(write)
+                    g(vec, write)
+        except StandardError:
+            pass
+        else:
+            self.fail("does not fail on too many files open")
+        for g in sink_list:
+            g.close()
+        shutil.rmtree(tmpdir)
+            f = source(path, samplerate, hop_size)
+        except RuntimeError as e:
+            self.skipTest('failed opening with hop_s = {:d}, samplerate = {:d} ({:s})'.format(hop_size, samplerate, str(e)))
+        if samplerate == 0: samplerate = f.samplerate
+        sink_path = get_tmp_sink_path()
+        g = sink(sink_path, samplerate)
+        total_frames = 0
+        while True:
+            vec, read = f()
+            g(vec, read)
+            total_frames += read
+            if read < f.hop_size: break
+        del_tmp_sink_path(sink_path)
+    def test_read_and_write(self):
+        if not len(list_of_sounds):
+            self.skipTest('add some sound files in \'python/tests/sounds\'')
+        for path in list_of_sounds:
+            for samplerate, hop_size in zip([0, 44100, 8000, 32000], [512, 1024, 64, 256]):
+                f = source(path, samplerate, hop_size)
+                if samplerate == 0: samplerate = f.samplerate
+                sink_path = get_tmp_sink_path()
+                g = sink(sink_path, samplerate)
+                total_frames = 0
+                while True:
+                    vec, read = f()
+                    g(vec, read)
+                    total_frames += read
+                    if read < f.hop_size: break
+                if 0:
+                    print "read", "%.2fs" % (total_frames / float(f.samplerate) ),
+                    print "(", total_frames, "frames", "in",
+                    print total_frames / f.hop_size, "blocks", "at", "%dHz" % f.samplerate, ")",
+                    print "from", f.uri,
+                    print "to", g.uri
+                del_tmp_sink_path(sink_path)
+    def test_read_and_write_multi(self):
+        if not len(list_of_sounds):
+            self.skipTest('add some sound files in \'python/tests/sounds\'')
+        for path in list_of_sounds:
+            for samplerate, hop_size in zip([0, 44100, 8000, 32000], [512, 1024, 64, 256]):
+                f = source(path, samplerate, hop_size)
+                if samplerate == 0: samplerate = f.samplerate
+                sink_path = get_tmp_sink_path()
+                g = sink(sink_path, samplerate, channels = f.channels)
+                total_frames = 0
+                while True:
+                    vec, read = f.do_multi()
+                    g.do_multi(vec, read)
+                    total_frames += read
+                    if read < f.hop_size: break
+                if 0:
+                    print "read", "%.2fs" % (total_frames / float(f.samplerate) ),
+                    print "(", total_frames, "frames", "in",
+                    print f.channels, "channels", "in",
+                    print total_frames / f.hop_size, "blocks", "at", "%dHz" % f.samplerate, ")",
+                    print "from", f.uri,
+                    print "to", g.uri,
+                    print "in", g.channels, "channels"
+                del_tmp_sink_path(sink_path)
+    @params(*all_params)
+    def test_read_and_write_multi(self, hop_size, samplerate, path):
+        try:
+            f = source(path, samplerate, hop_size)
+        except RuntimeError as e:
+            self.skipTest('failed opening with hop_s = {:d}, samplerate = {:d} ({:s})'.format(hop_size, samplerate, str(e)))
+        if samplerate == 0: samplerate = f.samplerate
+        sink_path = get_tmp_sink_path()
+        g = sink(sink_path, samplerate, channels = f.channels)
+        total_frames = 0
+        while True:
+            vec, read = f.do_multi()
+            g.do_multi(vec, read)
+            total_frames += read
+            if read < f.hop_size: break
+        del_tmp_sink_path(sink_path)
     def test_close_file(self):
 …
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_slicing.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, run_module_suite
+from numpy.testing import assert_equal, assert_almost_equal
+from unittest import main
+from numpy.testing import TestCase, assert_equal
 from aubio import slice_source_at_stamps
+from utils import *
+from utils import count_files_in_directory, get_default_test_sound
+from utils import count_samples_in_directory, count_samples_in_file
 import tempfile
 …
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_source.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from numpy.testing import TestCase, assert_equal, assert_almost_equal
+from aubio import fvec, source
+from numpy import array
+from nose2 import main
+from nose2.tools import params
+from numpy.testing import TestCase
+from aubio import source
 from utils import list_all_sounds
 list_of_sounds = list_all_sounds('sounds')
+samplerates = [0, 44100, 8000, 32000]
+hop_sizes = [512, 1024, 64]
 path = None
+all_params = []
+for soundfile in list_of_sounds:
+    for hop_size in hop_sizes:
+        for samplerate in samplerates:
+            all_params.append((hop_size, samplerate, soundfile))
 class aubio_source_test_case_base(TestCase):
 …
     def setUp(self):
         if not len(list_of_sounds): self.skipTest('add some sound files in \'python/tests/sounds\'')
+        self.default_test_sound = list_of_sounds[0]
 class aubio_source_test_case(aubio_source_test_case_base):
 …
         total_frames = 0
         while True:
             vec, read = f()
+            _ , read = f()
             total_frames += read
             if read < f.hop_size: break
+        print "read", "%.2fs" % (total_frames / float(f.samplerate) ),
+        print "(", total_frames, "frames", "in",
+        print total_frames / f.hop_size, "blocks", "at", "%dHz" % f.samplerate, ")",
+        print "from", f.uri
+        #result_str = "read {:.2f}s ({:d} frames in {:d} blocks at {:d}Hz) from {:s}"
+        #result_params = total_frames / float(f.samplerate), total_frames, total_frames//f.hop_size, f.samplerate, f.uri
+        #print (result_str.format(*result_params))
         return total_frames
+    def test_samplerate_hopsize(self):
+        for p in list_of_sounds:
+            for samplerate, hop_size in zip([0, 44100, 8000, 32000], [ 512, 512, 64, 256]):
+                f = source(p, samplerate, hop_size)
+                assert f.samplerate != 0
+                self.read_from_source(f)
+    @params(*all_params)
+    def test_samplerate_hopsize(self, hop_size, samplerate, soundfile):
+        try:
+            f = source(soundfile, samplerate, hop_size)
+        except RuntimeError as e:
+            self.skipTest('failed opening with hop_s = {:d}, samplerate = {:d} ({:s})'.format(hop_size, samplerate, str(e)))
+        assert f.samplerate != 0
+        self.read_from_source(f)
     def test_samplerate_none(self):
         for p in list_of_sounds:
             f = source(p)
             assert f.samplerate != 0
             self.read_from_source(f)
+    @params(*list_of_sounds)
+    def test_samplerate_none(self, p):
+        f = source(p)
+        assert f.samplerate != 0
+        self.read_from_source(f)
+    def test_samplerate_0(self):
+        for p in list_of_sounds:
+            f = source(p, 0)
+            assert f.samplerate != 0
+            self.read_from_source(f)
+    @params(*list_of_sounds)
+    def test_samplerate_0(self, p):
+        f = source(p, 0)
+        assert f.samplerate != 0
+        self.read_from_source(f)
+    @params(*list_of_sounds)
+    def test_zero_hop_size(self, p):
+        f = source(p, 0, 0)
+        assert f.samplerate != 0
+        assert f.hop_size != 0
+        self.read_from_source(f)
+    @params(*list_of_sounds)
+    def test_seek_to_half(self, p):
+        from random import randint
+        f = source(p, 0, 0)
+        assert f.samplerate != 0
+        assert f.hop_size != 0
+        a = self.read_from_source(f)
+        c = randint(0, a)
+        f.seek(c)
+        b = self.read_from_source(f)
+        assert a == b + c
+    @params(*list_of_sounds)
+    def test_duration(self, p):
+        total_frames = 0
+        f = source(p)
+        duration = f.duration
+        while True:
+            _, read = f()
+            total_frames += read
+            if read < f.hop_size: break
+        self.assertEqual(duration, total_frames)
+class aubio_source_test_wrong_params(TestCase):
+    def test_wrong_file(self):
+        with self.assertRaises(RuntimeError):
+            source('path_to/unexisting file.mp3')
+class aubio_source_test_wrong_params_with_file(aubio_source_test_case_base):
     def test_wrong_samplerate(self):
+        for p in list_of_sounds:
+            try:
+                f = source(p, -1)
+            except ValueError, e:
+                pass
+            else:
+                self.fail('negative samplerate does not raise ValueError')
+        with self.assertRaises(ValueError):
+            source(self.default_test_sound, -1)
     def test_wrong_hop_size(self):
+        for p in list_of_sounds:
+            try:
+                f = source(p, 0, -1)
+            except ValueError, e:
+                pass
+            else:
+                self.fail('negative hop_size does not raise ValueError')
+        with self.assertRaises(ValueError):
+            source(self.default_test_sound, 0, -1)
+    def test_zero_hop_size(self):
+        for p in list_of_sounds:
+            f = source(p, 0, 0)
+            assert f.samplerate != 0
+            assert f.hop_size != 0
+            self.read_from_source(f)
+    def test_wrong_channels(self):
+        with self.assertRaises(ValueError):
+            source(self.default_test_sound, 0, 0, -1)
+    def test_seek_to_half(self):
+        from random import randint
+        for p in list_of_sounds:
+            f = source(p, 0, 0)
+            assert f.samplerate != 0
+            assert f.hop_size != 0
+            a = self.read_from_source(f)
+            c = randint(0, a)
+            f.seek(c)
+            b = self.read_from_source(f)
+            assert a == b + c
+    def test_wrong_seek(self):
+        f = source(self.default_test_sound)
+        with self.assertRaises(ValueError):
+            f.seek(-1)
+    def test_wrong_seek_too_large(self):
+        f = source(self.default_test_sound)
+        try:
+            with self.assertRaises(ValueError):
+                f.seek(f.duration + f.samplerate * 10)
+        except AssertionError:
+            self.skipTest('seeking after end of stream failed raising ValueError')
 class aubio_source_readmulti_test_case(aubio_source_read_test_case):
 …
         total_frames = 0
         while True:
             vec, read = f.do_multi()
+            _, read = f.do_multi()
             total_frames += read
             if read < f.hop_size: break
+        print "read", "%.2fs" % (total_frames / float(f.samplerate) ),
+        print "(", total_frames, "frames", "in",
+        print f.channels, "channels and",
+        print total_frames / f.hop_size, "blocks", "at", "%dHz" % f.samplerate, ")",
+        print "from", f.uri
+        #result_str = "read {:.2f}s ({:d} frames in {:d} channels and {:d} blocks at {:d}Hz) from {:s}"
+        #result_params = total_frames / float(f.samplerate), total_frames, f.channels, int(total_frames/f.hop_size), f.samplerate, f.uri
+        #print (result_str.format(*result_params))
         return total_frames
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_specdesc.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from unittest import main
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from numpy import random, arange, log, zeros
+from aubio import specdesc, cvec
+from math import pi
+from aubio import specdesc, cvec, float_type
 methods = ["default",
 …
         for method in methods:
+          o = specdesc(method, buf_size)
+          assert_equal ([o.buf_size, o.method], [buf_size, method])
+          spec = cvec(buf_size)
+          spec.norm[0] = 1
+          spec.norm[1] = 1./2.
+          #print "%20s" % method, str(o(spec))
+          o(spec)
+          spec.norm = random.random_sample((len(spec.norm),)).astype('float32')
+          spec.phas = random.random_sample((len(spec.phas),)).astype('float32')
+          #print "%20s" % method, str(o(spec))
+          assert (o(spec) != 0.)
+    def test_hfc(self):
+        o = specdesc("hfc", buf_size)
+        spec = cvec(buf_size)
+        # hfc of zeros is zero
+        assert_equal (o(spec), 0.)
+        # hfc of ones is sum of all bin numbers
+        spec.norm[:] = 1
+        expected = sum(range(buf_size/2 + 2))
+        assert_equal (o(spec), expected)
+        # changing phase doesn't change anything
+        spec.phas[:] = 1
+        assert_equal (o(spec), sum(range(buf_size/2 + 2)))
+            o = specdesc(method, buf_size)
+            assert_equal ([o.buf_size, o.method], [buf_size, method])
+            spec = cvec(buf_size)
+            spec.norm[0] = 1
+            spec.norm[1] = 1./2.
+            #print "%20s" % method, str(o(spec))
+            o(spec)
+            spec.norm = random.random_sample((len(spec.norm),)).astype(float_type)
+            spec.phas = random.random_sample((len(spec.phas),)).astype(float_type)
+            #print "%20s" % method, str(o(spec))
+            assert (o(spec) != 0.)
     def test_phase(self):
 …
         # phase of zeros is zero
         assert_equal (o(spec), 0.)
         spec.phas = random.random_sample((len(spec.phas),)).astype('float32')
+        spec.phas = random.random_sample((len(spec.phas),)).astype(float_type)
         # phase of random is not zero
         spec.norm[:] = 1
 …
         # specdiff of zeros is zero
         assert_equal (o(spec), 0.)
         spec.phas = random.random_sample((len(spec.phas),)).astype('float32')
+        spec.phas = random.random_sample((len(spec.phas),)).astype(float_type)
         # phase of random is not zero
         spec.norm[:] = 1
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         assert_equal (a, c.norm)
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         assert_equal (a, c.norm)
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         assert_almost_equal( sum(a * log(1.+ a/1.e-1 ) ) / o(c), 1., decimal=6)
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         assert_almost_equal( sum(log(1.+ a/1.e-1 ) ) / o(c), 1, decimal=6)
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         assert_equal( sum(a), o(c))
         assert_equal( 0, o(c))
         c.norm = zeros(c.length, dtype='float32')
+        c.norm = zeros(c.length, dtype=float_type)
         assert_equal( 0, o(c))
 …
         # make sure centroid of zeros is zero
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         centroid = sum(a*a) / sum(a)
 …
         o = specdesc("spread")
         c = cvec(2048)
         ramp = arange(c.length, dtype='float32')
+        ramp = arange(c.length, dtype=float_type)
         assert_equal( 0., o(c))
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         centroid = sum(a*a) / sum(a)
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length, dtype='float32')
+        a = arange(c.length, dtype=float_type)
         c.norm = a
         centroid = sum(a*a) / sum(a)
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length * 2, 0, -2, dtype='float32')
         k = arange(c.length, dtype='float32')
+        a = arange(c.length * 2, 0, -2, dtype=float_type)
+        k = arange(c.length, dtype=float_type)
         c.norm = a
         num = len(a) * sum(k*a) - sum(k)*sum(a)
 …
         assert_almost_equal (slope, o(c), decimal = 5)
         a = arange(0, c.length * 2, +2, dtype='float32')
+        a = arange(0, c.length * 2, +2, dtype=float_type)
         c.norm = a
         num = len(a) * sum(k*a) - sum(k)*sum(a)
 …
         assert_almost_equal (slope, o(c), decimal = 5)
         a = arange(0, c.length * 2, +2, dtype='float32')
+        a = arange(0, c.length * 2, +2, dtype=float_type)
         c.norm = a * 2
         assert_almost_equal (slope, o(c), decimal = 5)
 …
         c = cvec()
         assert_equal( 0., o(c))
         a = arange(c.length * 2, 0, -2, dtype='float32')
         k = arange(c.length, dtype='float32')
+        a = arange(c.length * 2, 0, -2, dtype=float_type)
+        k = arange(c.length, dtype=float_type)
         c.norm = a
         decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:])
         assert_almost_equal (decrease, o(c), decimal = 5)
         a = arange(0, c.length * 2, +2, dtype='float32')
+        a = arange(0, c.length * 2, +2, dtype=float_type)
         c.norm = a
         decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:])
         assert_almost_equal (decrease, o(c), decimal = 5)
         a = arange(0, c.length * 2, +2, dtype='float32')
+        a = arange(0, c.length * 2, +2, dtype=float_type)
         c.norm = a * 2
         decrease = sum((a[1:] - a [0]) / k[1:]) / sum(a[1:])
 …
         c = cvec()
         assert_equal( 0., o(c))
+        a = arange(c.length * 2, 0, -2, dtype='float32')
+        k = arange(c.length, dtype='float32')
+        a = arange(c.length * 2, 0, -2, dtype=float_type)
         c.norm = a
         cumsum = .95*sum(a*a)
         i = 0; rollsum = 0
         while rollsum < cumsum:
           rollsum += a[i]*a[i]
           i+=1
+            rollsum += a[i]*a[i]
+            i+=1
         rolloff = i
         assert_equal (rolloff, o(c))
+class aubio_specdesc_wrong(TestCase):
+    def test_negative(self):
+        with self.assertRaises(ValueError):
+            specdesc("default", -10)
+    def test_unknown(self):
+        # FIXME should fail?
+        with self.assertRaises(ValueError):
+            specdesc("unknown", 512)
+            self.skipTest('todo: new_specdesc should fail on wrong method')
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/test_zero_crossing_rate.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+from unittest import main
 from numpy.testing import TestCase
 from aubio import fvec, zero_crossing_rate
 …
     def test_impulse(self):
         """ check zero crossing rate on a buffer with an impulse """
         self.vector[buf_size / 2] = 1.
+        self.vector[int(buf_size / 2)] = 1.
         self.assertEqual(0., zero_crossing_rate(self.vector))
     def test_negative_impulse(self):
         """ check zero crossing rate on a buffer with a negative impulse """
         self.vector[buf_size / 2] = -1.
+        self.vector[int(buf_size / 2)] = -1.
         self.assertEqual(2./buf_size, zero_crossing_rate(self.vector))
     def test_single(self):
         """ check zero crossing rate on single crossing """
         self.vector[buf_size / 2 - 1] = 1.
         self.vector[buf_size / 2] = -1.
+        self.vector[int(buf_size / 2) - 1] = 1.
+        self.vector[int(buf_size / 2)] = -1.
         self.assertEqual(2./buf_size, zero_crossing_rate(self.vector))
     def test_single_with_gap(self):
         """ check zero crossing rate on single crossing with a gap"""
         self.vector[buf_size / 2 - 2] = 1.
         self.vector[buf_size / 2] = -1.
+        self.vector[int(buf_size / 2) - 2] = 1.
+        self.vector[int(buf_size / 2)] = -1.
         self.assertEqual(2./buf_size, zero_crossing_rate(self.vector))
 if __name__ == '__main__':
-    from unittest import main
     main()

python/tests/utils.py

-                      r60fc05b
+                      rf264b17
 #! /usr/bin/env python
+import os
+import glob
+import numpy as np
+from tempfile import mkstemp
 def array_from_text_file(filename, dtype = 'float'):
-    import os.path
-    from numpy import array
     filename = os.path.join(os.path.dirname(__file__), filename)
+    return array([line.split() for line in open(filename).readlines()],
+        dtype = dtype)
+    with open(filename) as f:
+        lines = f.readlines()
+    return np.array([line.split() for line in lines],
+            dtype = dtype)
 def list_all_sounds(rel_dir):
-    import os.path, glob
     datadir = os.path.join(os.path.dirname(__file__), rel_dir)
     return glob.glob(os.path.join(datadir,'*.*'))
 …
 def get_tmp_sink_path():
-    from tempfile import mkstemp
-    import os
     fd, path = mkstemp()
     os.close(fd)
 …
 def del_tmp_sink_path(path):
+    import os
+    os.unlink(path)
+    try:
+        os.unlink(path)
+    except WindowsError as e:
+        print("deleting {:s} failed ({:s}), reopening".format(path, repr(e)))
+        with open(path, 'wb') as f:
+            f.close()
+        try:
+            os.unlink(path)
+        except WindowsError as f:
+            print("deleting {:s} failed ({:s}), aborting".format(path, repr(e)))
 def array_from_yaml_file(filename):
 …
     total_frames = 0
     while True:
         samples, read = s()
+        _, read = s()
         total_frames += read
         if read < hopsize: break
 …
 def count_samples_in_directory(samples_dir):
-    import os
     total_frames = 0
     for f in os.walk(samples_dir):
 …
 def count_files_in_directory(samples_dir):
-    import os
     total_files = 0
     for f in os.walk(samples_dir):

Context Navigation

Legend:

Download in other formats: