Python 3.7 compatibility; add stft.py to remove librosa dependency.

audfprint.py

@@ -23,6 +23,14 @@
 import hash_table # My hash_table implementation
 
 
+if sys.version_info[0] >= 3:
+ # Python 3 specific definitions
+ time_clock = time.process_time
+else:
+ # Python 2 specific definitions
+ time_clock = time.clock
+
+
 def filename_list_iterator(filelist, wavdir, wavext, listflag):
  """ Iterator to yeild all the filenames, possibly interpreting them
  as list files, prepending wavdir """
@@ -395,7 +403,7 @@ def main(argv):
  report = setup_reporter(args)
 
  # Keep track of wall time
- initticks = time.clock()
+ initticks = time_clock()
 
  # Command line sanity.
  if args["--maxtimebits"]:
@@ -472,7 +480,7 @@ def main(argv):
  skip_existing=args['--skip-existing'],
  strip_prefix=args['--wavdir'])
 
- elapsedtime = time.clock() - initticks
+ elapsedtime = time_clock() - initticks
  if analyzer and analyzer.soundfiletotaldur > 0.:
  print("Processed "
  + "%d files (%.1f s total dur) in %.1f s sec = %.3f x RT" \

audfprint_analyze.py

@@ -14,18 +14,13 @@
 import struct # For reading/writing hashes to file
 import time # For glob2hashtable, localtester
 
-import librosa
 import numpy as np
 import scipy.signal
 
 import audio_read
 import hash_table # For utility, glob2hashtable
+import stft
 
-try:
- # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
- xrange(0) # Py2
-except NameError:
- xrange = range # Py3
 
 # ############### Globals ############### #
 # Special extension indicating precomputed fingerprint
@@ -275,9 +270,9 @@ def find_peaks(self, d, sr):
  a_dec = (1 - 0.01 * (self.density * np.sqrt(self.n_hop / 352.8) / 35)) ** (1 / OVERSAMP)
  # Take spectrogram
  mywin = np.hanning(self.n_fft + 2)[1:-1]
- sgram = np.abs(librosa.stft(d, n_fft=self.n_fft,
-  hop_length=self.n_hop,
-  window=mywin))
+ sgram = np.abs(stft.stft(d, n_fft=self.n_fft,
+ hop_length=self.n_hop,
+ window=mywin))
  sgrammax = np.max(sgram)
  if sgrammax > 0.0:
  sgram = np.log(np.maximum(sgram, np.max(sgram) / 1e6))
@@ -300,7 +295,7 @@ def find_peaks(self, d, sr):
  # build a list of peaks we ended up with
  scols = np.shape(sgram)[1]
  pklist = []
- for col in xrange(scols):
+ for col in range(scols):
  for bin_ in np.nonzero(peaks[:, col])[0]:
  pklist.append((col, bin_))
  return pklist
@@ -318,15 +313,15 @@ def peaks2landmarks(self, pklist):
  # Find column of the final peak in the list
  scols = pklist[-1][0] + 1
  # Convert (col, bin) list into peaks_at[col] lists
- peaks_at = [[] for _ in xrange(scols)]
+ peaks_at = [[] for _ in range(scols)]
  for (col, bin_) in pklist:
  peaks_at[col].append(bin_)
 
  # Build list of landmarks <starttime F1 endtime F2>
- for col in xrange(scols):
+ for col in range(scols):
  for peak in peaks_at[col]:
  pairsthispeak = 0
- for col2 in xrange(col + self.mindt,
+ for col2 in range(col + self.mindt,
  min(scols, col + self.targetdt)):
  if pairsthispeak < self.maxpairsperpeak:
  for peak2 in peaks_at[col2]:

audfprint_match.py

@@ -11,15 +11,19 @@
 import time
 
 import psutil
-import matplotlib.pyplot as plt
-import librosa
-import librosa.display
 import numpy as np
 import scipy.signal
 
+# Don't sweat failure to import graphics support.
+try:
+ import matplotlib.pyplot as plt
+ import librosa.display
+except:
+ pass
+
 import audfprint_analyze # for localtest and illustrate
 import audio_read
-
+import stft
 
 def process_info():
  rss = usrtime = 0
@@ -420,9 +424,9 @@ def illustrate_match(self, analyzer, ht, filename):
  # Make the spectrogram
  # d, sr = librosa.load(filename, sr=analyzer.target_sr)
  d, sr = audio_read.audio_read(filename, sr=analyzer.target_sr, channels=1)
- sgram = np.abs(librosa.stft(d, n_fft=analyzer.n_fft,
-  hop_length=analyzer.n_hop,
-  window=np.hanning(analyzer.n_fft + 2)[1:-1]))
+ sgram = np.abs(stft.stft(d, n_fft=analyzer.n_fft,
+ hop_length=analyzer.n_hop,
+ window=np.hanning(analyzer.n_fft + 2)[1:-1]))
  sgram = 20.0 * np.log10(np.maximum(sgram, np.max(sgram) / 1e6))
  sgram = sgram - np.mean(sgram)
  # High-pass filter onset emphasis

hash_table.py

@@ -13,26 +13,21 @@
 import math
 import os
 import random
+import sys
 
 import numpy as np
 import scipy.io
 
-try:
- import cPickle as pickle # Py2
-except ImportError:
+if sys.version_info[0] >= 3:
+ # Python 3 specific definitions
  import pickle # Py3
-
-try:
- # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
- xrange(0) # Py2
-except NameError:
- xrange = range # Py3
-
-try:
- # noinspection PyUnresolvedReferences,PyUnboundLocalVariable
- basestring # Py2
-except NameError:
  basestring = (str, bytes) # Py3
+ pickle_options = {'encoding': 'latin1'}
+else:
+ # Python 2 specific definitions
+ import cPickle as pickle # Py2
+ pickle_options = {}
+
 
 # Current format version
 HT_VERSION = 20170724
@@ -164,7 +159,7 @@ def get_hits(self, hashes):
  maxtimemask = (1 << self.maxtimebits) - 1
  hashmask = (1 << self.hashbits) - 1
  # Fill in
- for ix in xrange(nhashes):
+ for ix in range(nhashes):
  time_ = hashes[ix][0]
  hash_ = hashmask & hashes[ix][1]
  nids = min(self.depth, self.counts[hash_])
@@ -221,7 +216,7 @@ def load_pkl(self, name, file_object=None):
  f = file_object
  else:
  f = gzip.open(name, 'rb')
- temp = pickle.load(f)
+ temp = pickle.load(f, **pickle_options)
  if temp.ht_version < HT_OLD_COMPAT_VERSION:
  raise ValueError('Version of ' + name + ' is ' + str(temp.ht_version)
  + ' which is not at least ' +

requirements.txt

@@ -1,4 +1,3 @@
-librosa
 numpy
 scipy
 docopt

stft.py

@@ -0,0 +1,94 @@
+"""Provide stft to avoid librosa dependency. 
+
+This implementation is based on routines from 
+https://github.com/tensorflow/models/blob/master/research/audioset/mel_features.py
+"""
+
+from __future__ import division
+
+import numpy as np
+
+
+def frame(data, window_length, hop_length):
+ """Convert array into a sequence of successive possibly overlapping frames.
+
+ An n-dimensional array of shape (num_samples, ...) is converted into an
+ (n+1)-D array of shape (num_frames, window_length, ...), where each frame
+ starts hop_length points after the preceding one.
+
+ This is accomplished using stride_tricks, so the original data is not
+ copied. However, there is no zero-padding, so any incomplete frames at the
+ end are not included.
+
+ Args:
+ data: np.array of dimension N >= 1.
+ window_length: Number of samples in each frame.
+ hop_length: Advance (in samples) between each window.
+
+ Returns:
+ (N+1)-D np.array with as many rows as there are complete frames that can be
+ extracted.
+ """
+ num_samples = data.shape[0]
+ num_frames = 1 + ((num_samples - window_length) // hop_length)
+ shape = (num_frames, window_length) + data.shape[1:]
+ strides = (data.strides[0] * hop_length,) + data.strides
+ return np.lib.stride_tricks.as_strided(data, shape=shape, strides=strides)
+
+
+def periodic_hann(window_length):
+ """Calculate a "periodic" Hann window.
+
+ The classic Hann window is defined as a raised cosine that starts and
+ ends on zero, and where every value appears twice, except the middle
+ point for an odd-length window. Matlab calls this a "symmetric" window
+ and np.hanning() returns it. However, for Fourier analysis, this
+ actually represents just over one cycle of a period N-1 cosine, and
+ thus is not compactly expressed on a length-N Fourier basis. Instead,
+ it's better to use a raised cosine that ends just before the final
+ zero value - i.e. a complete cycle of a period-N cosine. Matlab
+ calls this a "periodic" window. This routine calculates it.
+
+ Args:
+ window_length: The number of points in the returned window.
+
+ Returns:
+ A 1D np.array containing the periodic hann window.
+ """
+ return 0.5 - (0.5 * np.cos(2 * np.pi / window_length *
+ np.arange(window_length)))
+
+
+def stft(signal, n_fft, hop_length=None, window=None):
+ """Calculate the short-time Fourier transform.
+
+ Args:
+ signal: 1D np.array of the input time-domain signal.
+ n_fft: Size of the FFT to apply.
+ hop_length: Advance (in samples) between each frame passed to FFT. Defaults
+ to half the window length.
+ window: Length of each block of samples to pass to FFT, or vector of window
+ values. Defaults to n_fft.
+
+ Returns:
+ 2D np.array where each column contains the complex values of the 
+ fft_length/2+1 unique values of the FFT for the corresponding frame of 
+ input samples ("spectrogram transposition").
+ """
+ if window is None:
+ window = n_fft
+ if isinstance(window, (int, float)):
+ # window holds the window length, need to make the actual window.
+ window = periodic_hann(int(window))
+ window_length = len(window)
+ if not hop_length:
+ hop_length = window_length // 2
+ # Default librosa STFT behavior.
+ pad_mode = 'reflect'
+ signal = np.pad(signal, (n_fft // 2), mode=pad_mode)
+ frames = frame(signal, window_length, hop_length)
+ # Apply frame window to each frame. We use a periodic Hann (cosine of period
+ # window_length) instead of the symmetric Hann of np.hanning (period
+ # window_length-1).
+ windowed_frames = frames * window
+ return np.fft.rfft(windowed_frames, n_fft).transpose()