Changeset 633400d for python/demos

Timestamp:

Dec 5, 2018, 10:34:39 PM (6 years ago)

Author:

Paul Brossier <piem@piem.org>

Branches:

feature/cnn, feature/crepe, feature/pitchshift, feature/timestretch, fix/ffmpeg5, master

Children:

283a619a

Parents:

5b46bc3 (diff), f19db54 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into feature/pitchshift

Location:

python/demos

Files:

• demo_alsa.py (added)
• demo_bench_yin.py (added)
• demo_bpm_extract.py (modified) (3 diffs)
• demo_filter.py (modified) (1 diff)
• demo_filterbank.py (modified) (1 diff)
• demo_notes.py (added)
• demo_pitch_sinusoid.py (modified) (1 diff)
• demo_pyaudio.py (added)
• demo_source_simple.py (modified) (1 diff)
• demo_tapthebeat.py (added)
• demo_timestretch.py (modified) (1 diff)
• demo_timestretch_online.py (modified) (2 diffs)
• demo_wav2midi.py (added)
• demo_yin_compare.py (added)

python/demos/demo_bpm_extract.py

@@ -4 +4 @@
 from numpy import median, diff
 
-def get_file_bpm(path, params = None):
+def get_file_bpm(path, params=None):
     """ Calculate the beats per minute (bpm) of a given file.
         path: path to the file
@@ -11 +11 @@
     if params is None:
         params = {}
-    try:
-        win_s = params['win_s']
-        samplerate = params['samplerate']
-        hop_s = params['hop_s']
-    except KeyError:
-        """
-        # super fast
-        samplerate, win_s, hop_s = 4000, 128, 64 
-        # fast
-        samplerate, win_s, hop_s = 8000, 512, 128
-        """
-        # default:
-        samplerate, win_s, hop_s = 44100, 1024, 512
+    # default:
+    samplerate, win_s, hop_s = 44100, 1024, 512
+    if 'mode' in params:
+        if params.mode in ['super-fast']:
+            # super fast
+            samplerate, win_s, hop_s = 4000, 128, 64
+        elif params.mode in ['fast']:
+            # fast
+            samplerate, win_s, hop_s = 8000, 512, 128
+        elif params.mode in ['default']:
+            pass
+        else:
+            raise ValueError("unknown mode {:s}".format(params.mode))
+    # manual settings
+    if 'samplerate' in params:
+        samplerate = params.samplerate
+    if 'win_s' in params:
+        win_s = params.win_s
+    if 'hop_s' in params:
+        hop_s = params.hop_s
 
     s = source(path, samplerate, hop_s)
@@ -45 +52 @@
             break
 
-    # Convert to periods and to bpm 
-    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
+    def beats_to_bpm(beats, path):
+        # if enough beats are found, convert to periods then to bpm
+        if len(beats) > 1:
+            if len(beats) < 4:
+                print("few beats found in {:s}".format(path))
+            bpms = 60./diff(beats)
+            return median(bpms)
+        else:
+            print("not enough beats found in {:s}".format(path))
+            return 0
+
+    return beats_to_bpm(beats, path)
 
 if __name__ == '__main__':
-    import sys
-    for f in sys.argv[1:]:
-        bpm = get_file_bpm(f)
+    import argparse
+    parser = argparse.ArgumentParser()
+    parser.add_argument('-m', '--mode',
+            help="mode [default|fast|super-fast]",
+            dest="mode", default='default')
+    parser.add_argument('sources',
+            nargs='+',
+            help="input_files")
+    args = parser.parse_args()
+    for f in args.sources:
+        bpm = get_file_bpm(f, params = args)
         print("{:6s} {:s}".format("{:2f}".format(bpm), f))

python/demos/demo_filter.py

@@ -1 +1 @@
 #! /usr/bin/env python
 
+import sys
+import os.path
+import aubio
 
-def apply_filter(path):
-    from aubio import source, sink, digital_filter
-    from os.path import basename, splitext
 
+def apply_filter(path, target):
     # open input file, get its samplerate
-    s = source(path)
+    s = aubio.source(path)
     samplerate = s.samplerate
 
     # create an A-weighting filter
-    f = digital_filter(7)
+    f = aubio.digital_filter(7)
     f.set_a_weighting(samplerate)
-    # alternatively, apply another filter
 
     # create output file
-    o = sink("filtered_" + splitext(basename(path))[0] + ".wav", samplerate)
+    o = aubio.sink(target, samplerate)
 
     total_frames = 0
     while True:
+        # read from source
         samples, read = s()
+        # filter samples
         filtered_samples = f(samples)
+        # write to sink
         o(filtered_samples, read)
+        # count frames read
         total_frames += read
-        if read < s.hop_size: break
+        # end of file reached
+        if read < s.hop_size:
+            break
 
+    # print some info
     duration = total_frames / float(samplerate)
-    print ("read {:s}".format(s.uri))
-    print ("applied A-weighting filtered ({:d} Hz)".format(samplerate))
-    print ("wrote {:s} ({:.2f} s)".format(o.uri, duration))
+    input_str = "input: {:s} ({:.2f} s, {:d} Hz)"
+    output_str = "output: {:s}, A-weighting filtered ({:d} frames total)"
+    print(input_str.format(s.uri, duration, samplerate))
+    print(output_str.format(o.uri, total_frames))
 
 if __name__ == '__main__':
-    import sys
-    for f in sys.argv[1:]:
-        apply_filter(f)
+    usage = "{:s} <input_file> [output_file]".format(sys.argv[0])
+    if not 1 < len(sys.argv) < 4:
+        print(usage)
+        sys.exit(1)
+    if len(sys.argv) < 3:
+        input_path = sys.argv[1]
+        basename = os.path.splitext(os.path.basename(input_path))[0] + ".wav"
+        output_path = "filtered_" + basename
+    else:
+        input_path, output_path = sys.argv[1:]
+    # run function
+    apply_filter(input_path, output_path)

python/demos/demo_filterbank.py

@@ -1 +1 @@
 #! /usr/bin/env python
 
-from aubio import filterbank, fvec
-from pylab import loglog, show, xlim, ylim, xlabel, ylabel, title
-from numpy import vstack, arange
+"""Create a filterbank from a list of frequencies.
 
+This demo uses `aubio.filterbank.set_triangle_bands` to build a set of
+triangular filters from a list of frequencies.
+
+The filterbank coefficients are then modified before being displayed."""
+
+import aubio
+import numpy as np
+import matplotlib.pyplot as plt
+
+# sampling rate and size of the fft
+samplerate = 48000
 win_s = 2048
-samplerate = 48000
 
+# define a list of custom frequency
 freq_list = [60, 80, 200, 400, 800, 1600, 3200, 6400, 12800, 24000]
+# number of filters to create
 n_filters = len(freq_list) - 2
 
-f = filterbank(n_filters, win_s)
-freqs = fvec(freq_list)
+# create a new filterbank
+f = aubio.filterbank(n_filters, win_s)
+freqs = aubio.fvec(freq_list)
 f.set_triangle_bands(freqs, samplerate)
 
+# get the coefficients from the filterbank
 coeffs = f.get_coeffs()
-coeffs[4] *= 5.
-
+# apply a gain to fifth band
+coeffs[4] *= 6.
+# load the modified coeffs into the filterbank
 f.set_coeffs(coeffs)
 
-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, '.-')
-xlim([50, samplerate/2])
-ylim([1.0e-6, 2.0e-2])
-xlabel('log frequency (Hz)')
-ylabel('log amplitude')
-
-show()
+# display the band gains in a loglog plot
+freqs = np.vstack([np.arange(win_s // 2 + 1) * samplerate / win_s] * n_filters)
+plt.title('filterbank built from a list of frequencies\n'
+          'The 5th band has been amplified by a factor 6.')
+plt.loglog(freqs.T, f.get_coeffs().T, '.-')
+plt.xlim([50, samplerate/2])
+plt.ylim([1.0e-6, 2.0e-2])
+plt.xlabel('log frequency (Hz)')
+plt.ylabel('log amplitude')
+plt.show()

python/demos/demo_pitch_sinusoid.py

@@ -38 +38 @@
 pointer += partition
 pointer += partition
-freqs[ pointer : pointer + partition ] = 400 + 5 * np.random.random(sin_length/8)
+freqs[ pointer : pointer + partition ] = 400 + 5 * np.random.random(sin_length//8)
 
 a = build_sinusoid(sin_length, freqs, samplerate)

python/demos/demo_source_simple.py

@@ -1 +1 @@
 #! /usr/bin/env python
-import sys, aubio
+
+"""A simple example using aubio.source."""
+
+import sys
+import aubio
 
 samplerate = 0  # use original source samplerate
-hop_size = 256 # number of frames to read in one block
-s = aubio.source(sys.argv[1], samplerate, hop_size)
+hop_size = 256  # number of frames to read in one block
+src = aubio.source(sys.argv[1], samplerate, hop_size)
 total_frames = 0
 
-while True: # reading loop
-    samples, read = s()
-    total_frames += read
-    if read < hop_size: break # end of file reached
+while True:
+    samples, read = src()  # read hop_size new samples from source
+    total_frames += read   # increment total number of frames
+    if read < hop_size:    # end of file reached
+        break
 
 fmt_string = "read {:d} frames at {:d}Hz from {:s}"
-print (fmt_string.format(total_frames, s.samplerate, sys.argv[1]))
-
+print(fmt_string.format(total_frames, src.samplerate, src.uri))

python/demos/demo_timestretch.py

@@ -13 +13 @@
 
 win_s = 1024
-hop_s = win_s / 8 # 87.5 % overlap
+hop_s = win_s // 8 # 87.5 % overlap
 
 warmup = win_s // hop_s - 1

python/demos/demo_timestretch_online.py

@@ -12 +12 @@
 import numpy as np
 
-win_s = 1024
-hop_s = win_s / 8 # 87.5 % overlap
+win_s = 512
+hop_s = win_s // 8 # 87.5 % overlap
 
 warmup = win_s // hop_s - 1
@@ -93 +93 @@
     old_grain.phas = np.copy(cur_grain.phas)
 
+    # until end of file
+    if read < hop_s: break
+    # increment block counter
     block_read += 1
-    if read < hop_s: break
 
 for t in range(warmup + 2): # purge the last frames from the phase vocoder