Madmom documentation¶

madmom.audio.signal¶

This module contains basic signal processing functionality.

madmom.audio.signal.smooth(signal, kernel)[source]¶

Smooth the signal along its first axis.

Parameters:	signal : numpy array Signal to be smoothed. kernel : numpy array or int Smoothing kernel (size).
Returns:	numpy array Smoothed signal.

Notes

If kernel is an integer, a Hamming window of that length will be used as a smoothing kernel.

madmom.audio.signal.adjust_gain(signal, gain)[source]¶

” Adjust the gain of the signal.

Parameters:	signal : numpy array Signal to be adjusted. gain : float Gain adjustment level [dB].
Returns:	numpy array Signal with adjusted gain.

Notes

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

gain values > 0 amplify the signal and are only supported for signals with float dtype to prevent clipping and integer overflows.

madmom.audio.signal.attenuate(signal, attenuation)[source]¶

Attenuate the signal.

Parameters:	signal : numpy array Signal to be attenuated. attenuation : float Attenuation level [dB].
Returns:	numpy array Attenuated signal (same dtype as signal).

Notes

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

madmom.audio.signal.normalize(signal)[source]¶

Normalize the signal to have maximum amplitude.

Parameters:	signal : numpy array Signal to be normalized.
Returns:	numpy array Normalized signal.

Notes

Signals with float dtypes cover the range [-1, +1], signals with integer dtypes will cover the maximally possible range, e.g. [-32768, 32767] for np.int16.

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

madmom.audio.signal.remix(signal, num_channels)[source]¶

Remix the signal to have the desired number of channels.

Parameters:	signal : numpy array Signal to be remixed. num_channels : int Number of channels.
Returns:	numpy array Remixed signal (same dtype as signal).

Notes

This function does not support arbitrary channel number conversions. Only down-mixing to and up-mixing from mono signals is supported.

The signal is returned with the same dtype, thus rounding errors may occur with integer dtypes.

If the signal should be down-mixed to mono and has an integer dtype, it will be converted to float internally and then back to the original dtype to prevent clipping of the signal. To avoid this double conversion, convert the dtype first.

madmom.audio.signal.rescale(signal, dtype=<type 'numpy.float32'>)[source]¶

Rescale the signal to range [-1, 1] and return as float dtype.

Parameters:	signal : numpy array Signal to be remixed. dtype : numpy dtype Data type of the signal.
Returns:	numpy array Signal rescaled to range [-1, 1].

madmom.audio.signal.trim(signal, where='fb')[source]¶

Trim leading and trailing zeros of the signal.

Parameters:	signal : numpy array Signal to be trimmed. where : str, optional A string with ‘f’ representing trim from front and ‘b’ to trim from back. Default is ‘fb’, trim zeros from both ends of the signal.
Returns:	numpy array Trimmed signal.

madmom.audio.signal.root_mean_square(signal)[source]¶

Computes the root mean square of the signal. This can be used as a measurement of power.

Parameters:	signal : numpy array Signal.
Returns:	rms : float Root mean square of the signal.

madmom.audio.signal.sound_pressure_level(signal, p_ref=None)[source]¶

Computes the sound pressure level of a signal.

Parameters:	signal : numpy array Signal. p_ref : float, optional Reference sound pressure level; if ‘None’, take the max amplitude value for the data-type, if the data-type is float, assume amplitudes are between -1 and +1.
Returns:	spl : float Sound pressure level of the signal [dB].

Notes

From http://en.wikipedia.org/wiki/Sound_pressure: Sound pressure level (SPL) or sound level is a logarithmic measure of the effective sound pressure of a sound relative to a reference value. It is measured in decibels (dB) above a standard reference level.

madmom.audio.signal.load_wave_file(filename, sample_rate=None, num_channels=None, start=None, stop=None, dtype=None)[source]¶

Load the audio data from the given file and return it as a numpy array.

Only supports wave files, does not support re-sampling or arbitrary channel number conversions. Reads the data as a memory-mapped file with copy-on-write semantics to defer I/O costs until needed.

Parameters:

filename : string Name of the file. sample_rate : int, optional Desired sample rate of the signal [Hz], or ‘None’ to return the signal in its original rate. num_channels : int, optional Reduce or expand the signal to num_channels channels, or ‘None’ to return the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

Returns:

signal : numpy array Audio signal. sample_rate : int Sample rate of the signal [Hz].

Notes

The start and stop positions are rounded to the closest sample; the sample corresponding to the stop value is not returned, thus consecutive segment starting with the previous stop can be concatenated to obtain the original signal without gaps or overlaps.

exception madmom.audio.signal.LoadAudioFileError(value=None)[source]¶

Exception to be raised whenever an audio file could not be loaded.

madmom.audio.signal.load_audio_file(filename, sample_rate=None, num_channels=None, start=None, stop=None, dtype=None)[source]¶

Load the audio data from the given file and return it as a numpy array. This tries load_wave_file() load_ffmpeg_file() (for ffmpeg and avconv).

Parameters:

filename : str or file handle Name of the file or file handle. sample_rate : int, optional Desired sample rate of the signal [Hz], or ‘None’ to return the signal in its original rate. num_channels: int, optional Reduce or expand the signal to num_channels channels, or ‘None’ to return the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

Returns:

signal : numpy array Audio signal. sample_rate : int Sample rate of the signal [Hz].

Notes

For wave files, the start and stop positions are rounded to the closest sample; the sample corresponding to the stop value is not returned, thus consecutive segment starting with the previous stop can be concatenated to obtain the original signal without gaps or overlaps. For all other audio files, this can not be guaranteed.

class madmom.audio.signal.Signal(data, sample_rate=None, num_channels=None, start=None, stop=None, norm=False, gain=0, dtype=None)[source]¶

The Signal class represents a signal as a (memory-mapped) numpy array and enhances it with a number of attributes.

Parameters:

data : numpy array, str or file handle Signal data or file name or file handle. sample_rate : int, optional Desired sample rate of the signal [Hz], or ‘None’ to return the signal in its original rate. num_channels : int, optional Reduce or expand the signal to num_channels channels, or ‘None’ to return the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. norm : bool, optional Normalize the signal to the range [-1, +1]. gain : float, optional Adjust the gain of the signal [dB]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

Notes

sample_rate or num_channels can be used to set the desired sample rate and number of channels if the audio is read from file. If set to ‘None’ the audio signal is used as is, i.e. the sample rate and number of channels are determined directly from the audio file.

If the data is a numpy array, the sample_rate is set to the given value and num_channels is set to the number of columns of the array.

The gain can be used to adjust the level of the signal.

If both norm and gain are set, the signal is first normalized and then the gain is applied afterwards.

If norm or gain is set, the selected part of the signal is loaded into memory completely, i.e. .wav files are not memory-mapped any more.

num_samples¶

Number of samples.

num_channels¶

Number of channels.

length¶

Length of signal in seconds.

class madmom.audio.signal.SignalProcessor(sample_rate=None, num_channels=None, start=None, stop=None, norm=False, att=None, gain=0.0, **kwargs)[source]¶

The SignalProcessor class is a basic signal processor.

Parameters:

sample_rate : int, optional Sample rate of the signal [Hz]; if set the signal will be re-sampled to that sample rate; if ‘None’ the sample rate of the audio file will be used. num_channels : int, optional Number of channels of the signal; if set, the signal will be reduced to that number of channels; if ‘None’ as many channels as present in the audio file are returned. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. norm : bool, optional Normalize the signal to the range [-1, +1]. att : float, optional Deprecated in version 0.13, use gain instead. gain : float, optional Adjust the gain of the signal [dB]. dtype : numpy data type, optional The data is returned with the given dtype. If ‘None’, it is returned with its original dtype, otherwise the signal gets rescaled. Integer dtypes use the complete value range, float dtypes the range [-1, +1].

att¶

Attenuation of the signal [dB].

process(data, start=None, stop=None, **kwargs)[source]¶

Processes the given audio file.

Parameters:	data : numpy array, str or file handle Data to be processed. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds].
Returns:	signal : Signal instance Signal instance.

static add_arguments(parser, sample_rate=None, mono=None, start=None, stop=None, norm=None, gain=None)[source]¶

Add signal processing related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. sample_rate : int, optional Re-sample the signal to this sample rate [Hz]. mono : bool, optional Down-mix the signal to mono. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. norm : bool, optional Normalize the signal to the range [-1, +1]. gain : float, optional Adjust the gain of the signal [dB].

Returns:

argparse argument group Signal processing argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’. To include start and stop arguments with a default value of ‘None’, i.e. do not set any start or stop time, they can be set to ‘True’.

madmom.audio.signal.signal_frame(signal, index, frame_size, hop_size, origin=0)[source]¶

This function returns frame at index of the signal.

Parameters:	signal : numpy array Signal. index : int Index of the frame to return. frame_size : int Size of each frame in samples. hop_size : float Hop size in samples between adjacent frames. origin : int Location of the window center relative to the signal position.
Returns:	frame : numpy array Requested frame of the signal.

Notes

The reference sample of the first frame (index == 0) refers to the first sample of the signal, and each following frame is placed hop_size samples after the previous one.

The window is always centered around this reference sample. Its location relative to the reference sample can be set with the origin parameter. Arbitrary integer values can be given:

• zero centers the window on its reference sample
• negative values shift the window to the right
• positive values shift the window to the left

An origin of half the size of the frame_size results in windows located to the left of the reference sample, i.e. the first frame starts at the first sample of the signal.

The part of the frame which is not covered by the signal is padded with zeros.

This function is totally independent of the length of the signal. Thus, contrary to common indexing, the index ‘-1’ refers NOT to the last frame of the signal, but instead the frame left of the first frame is returned.

class madmom.audio.signal.FramedSignal(signal, frame_size=2048, hop_size=441.0, fps=None, origin=0, end='normal', num_frames=None, **kwargs)[source]¶

The FramedSignal splits a Signal into frames and makes it iterable and indexable.

Parameters:

signal : Signal instance Signal to be split into frames. frame_size : int, optional Size of one frame [samples]. hop_size : float, optional Progress hop_size samples between adjacent frames. fps : float, optional Use given frames per second; if set, this computes and overwrites the given hop_size value. origin : int, optional Location of the window relative to the reference sample of a frame. end : int or str, optional End of signal handling (see notes below). num_frames : int, optional Number of frames to return. kwargs : dict, optional If no Signal instance was given, one is instantiated with these additional keyword arguments.

Notes

The FramedSignal class is implemented as an iterator. It splits the given signal automatically into frames of frame_size length with hop_size samples (can be float, normal rounding applies) between the frames. The reference sample of the first frame refers to the first sample of the signal.

The location of the window relative to the reference sample of a frame can be set with the origin parameter (with the same behaviour as used by scipy.ndimage filters). Arbitrary integer values can be given:

• zero centers the window on its reference sample,
• negative values shift the window to the right,
• positive values shift the window to the left.

Additionally, it can have the following literal values:

• ‘center’, ‘offline’: the window is centered on its reference sample,
• ‘left’, ‘past’, ‘online’: the window is located to the left of its reference sample (including the reference sample),
• ‘right’, ‘future’: the window is located to the right of its reference sample.

The end parameter is used to handle the end of signal behaviour and can have these values:

• ‘normal’: stop as soon as the whole signal got covered by at least one frame (i.e. pad maximally one frame),
• ‘extend’: frames are returned as long as part of the frame overlaps with the signal to cover the whole signal.

Alternatively, num_frames can be used to retrieve a fixed number of frames.

In order to be able to stack multiple frames obtained with different frame sizes, the number of frames to be returned must be independent from the set frame_size. It is not guaranteed that every sample of the signal is returned in a frame unless the origin is either ‘right’ or ‘future’.

frame_rate¶

Frame rate (same as fps).

fps¶

Frames per second.

overlap_factor¶

Overlapping factor of two adjacent frames.

shape¶

Shape of the FramedSignal (frames x samples).

ndim¶

Dimensionality of the FramedSignal.

class madmom.audio.signal.FramedSignalProcessor(frame_size=2048, hop_size=441.0, fps=None, online=False, end='normal', **kwargs)[source]¶

Slice a Signal into frames.

Parameters:

frame_size : int, optional Size of one frame [samples]. hop_size : float, optional Progress hop_size samples between adjacent frames. fps : float, optional Use given frames per second; if set, this computes and overwrites the given hop_size value. online : bool, optional Operate in online mode (see notes below). end : int or str, optional End of signal handling (see FramedSignal). num_frames : int, optional Number of frames to return. kwargs : dict, optional If no Signal instance was given, one is instantiated with these additional keyword arguments.

Notes

The location of the window relative to its reference sample can be set with the online parameter:

• ‘False’: the window is centered on its reference sample,
• ‘True’: the window is located to the left of its reference sample (including the reference sample), i.e. only past information is used.

process(data, **kwargs)[source]¶

Slice the signal into (overlapping) frames.

Parameters:	data : Signal instance Signal to be sliced into frames. kwargs : dict Keyword arguments passed to FramedSignal to instantiate the returned object.
Returns:	frames : FramedSignal instance FramedSignal instance

static add_arguments(parser, frame_size=2048, fps=100.0, online=None)[source]¶

Add signal framing related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser object. frame_size : int, optional Size of one frame in samples. fps : float, optional Frames per second. online : bool, optional Online mode (use only past signal information, i.e. align the window to the left of the reference sample).
Returns:	argparse argument group Signal framing argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

madmom.audio.filters¶

This module contains filter and filterbank related functionality.

madmom.audio.filters.hz2mel(f)[source]¶

Convert Hz frequencies to Mel.

Parameters:	f : numpy array Input frequencies [Hz].
Returns:	m : numpy array Frequencies in Mel [Mel].

madmom.audio.filters.mel2hz(m)[source]¶

Convert Mel frequencies to Hz.

Parameters:	m : numpy array Input frequencies [Mel].
Returns:	f: numpy array Frequencies in Hz [Hz].

madmom.audio.filters.mel_frequencies(num_bands, fmin, fmax)[source]¶

Returns frequencies aligned on the Mel scale.

Parameters:	num_bands : int Number of bands. fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz].
Returns:	mel_frequencies: numpy array Frequencies with Mel spacing [Hz].

madmom.audio.filters.bark_frequencies(fmin=20.0, fmax=15500.0)[source]¶

Returns frequencies aligned on the Bark scale.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz].
Returns:	bark_frequencies : numpy array Frequencies with Bark spacing [Hz].

madmom.audio.filters.bark_double_frequencies(fmin=20.0, fmax=15500.0)[source]¶

Returns frequencies aligned on the Bark-scale.

The list also includes center frequencies between the corner frequencies.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz].
Returns:	bark_frequencies : numpy array Frequencies with Bark spacing [Hz].

madmom.audio.filters.log_frequencies(bands_per_octave, fmin, fmax, fref=440.0)[source]¶

Returns frequencies aligned on a logarithmic frequency scale.

Parameters:	bands_per_octave : int Number of filter bands per octave. fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz]. fref : float, optional Tuning frequency [Hz].
Returns:	log_frequencies : numpy array Logarithmically spaced frequencies [Hz].

Notes

If bands_per_octave = 12 and fref = 440 are used, the frequencies are equivalent to MIDI notes.

madmom.audio.filters.semitone_frequencies(fmin, fmax, fref=440.0)[source]¶

Returns frequencies separated by semitones.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz]. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	semitone_frequencies : numpy array Semitone frequencies [Hz].

madmom.audio.filters.hz2midi(f, fref=440.0)[source]¶

Convert frequencies to the corresponding MIDI notes.

Parameters:	f : numpy array Input frequencies [Hz]. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	m : numpy array MIDI notes

Notes

For details see: at http://www.phys.unsw.edu.au/jw/notes.html This function does not necessarily return a valid MIDI Note, you may need to round it to the nearest integer.

madmom.audio.filters.midi2hz(m, fref=440.0)[source]¶

Convert MIDI notes to corresponding frequencies.

Parameters:	m : numpy array Input MIDI notes. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	f : numpy array Corresponding frequencies [Hz].

madmom.audio.filters.midi_frequencies(fmin, fmax, fref=440.0)¶

Returns frequencies separated by semitones.

Parameters:	fmin : float Minimum frequency [Hz]. fmax : float Maximum frequency [Hz]. fref : float, optional Tuning frequency of A4 [Hz].
Returns:	semitone_frequencies : numpy array Semitone frequencies [Hz].

madmom.audio.filters.hz2erb(f)[source]¶

Convert Hz to ERB.

Parameters:	f : numpy array Input frequencies [Hz].
Returns:	e : numpy array Frequencies in ERB [ERB].

Notes

Information about the ERB scale can be found at: https://ccrma.stanford.edu/~jos/bbt/Equivalent_Rectangular_Bandwidth.html

madmom.audio.filters.erb2hz(e)[source]¶

Convert ERB scaled frequencies to Hz.

Parameters:	e : numpy array Input frequencies [ERB].
Returns:	f : numpy array Frequencies in Hz [Hz].

Notes

Information about the ERB scale can be found at: https://ccrma.stanford.edu/~jos/bbt/Equivalent_Rectangular_Bandwidth.html

madmom.audio.filters.frequencies2bins(frequencies, bin_frequencies, unique_bins=False)[source]¶

Map frequencies to the closest corresponding bins.

Parameters:	frequencies : numpy array Input frequencies [Hz]. bin_frequencies : numpy array Frequencies of the (FFT) bins [Hz]. unique_bins : bool, optional Return only unique bins, i.e. remove all duplicate bins resulting from insufficient resolution at low frequencies.
Returns:	bins : numpy array Corresponding (unique) bins.

Notes

It can be important to return only unique bins, otherwise the lower frequency bins can be given too much weight if all bins are simply summed up (as in the spectral flux onset detection).

madmom.audio.filters.bins2frequencies(bins, bin_frequencies)[source]¶

Convert bins to the corresponding frequencies.

Parameters:	bins : numpy array Bins (e.g. FFT bins). bin_frequencies : numpy array Frequencies of the (FFT) bins [Hz].
Returns:	f : numpy array Corresponding frequencies [Hz].

class madmom.audio.filters.Filter(data, start=0, norm=False)[source]¶

Generic Filter class.

Parameters:	data : 1D numpy array Filter data. start : int, optional Start position (see notes). norm : bool, optional Normalize the filter area to 1.

Notes

The start position is mandatory if a Filter should be used for the creation of a Filterbank.

classmethod band_bins(bins, **kwargs)[source]¶

Must yield the center/crossover bins needed for filter creation.

Parameters:	bins : numpy array Center/crossover bins used for the creation of filters. kwargs : dict, optional Additional parameters for for the creation of filters (e.g. if the filters should overlap or not).

classmethod filters(bins, norm, **kwargs)[source]¶

Create a list with filters for the the given bins.

Parameters:	bins : list or numpy array Center/crossover bins of the filters. norm : bool Normalize the area of the filter(s) to 1. kwargs : dict, optional Additional parameters passed to band_bins() (e.g. if the filters should overlap or not).
Returns:	filters : list Filter(s) for the given bins.

class madmom.audio.filters.TriangularFilter(start, center, stop, norm=False)[source]¶

Triangular filter class.

Create a triangular shaped filter with length stop, height 1 (unless normalized) with indices <= start set to 0.

Parameters:	start : int Start bin of the filter. center : int Center bin of the filter. stop : int Stop bin of the filter. norm : bool, optional Normalize the area of the filter to 1.

classmethod band_bins(bins, overlap=True)[source]¶

Yields start, center and stop bins for creation of triangular filters.

Parameters:	bins : list or numpy array Center bins of filters. overlap : bool, optional Filters should overlap (see notes).
Yields:	start : int Start bin of the filter. center : int Center bin of the filter. stop : int Stop bin of the filter.

Notes

If overlap is ‘False’, the start and stop bins of the filters are interpolated between the centre bins, normal rounding applies.

class madmom.audio.filters.RectangularFilter(start, stop, norm=False)[source]¶

Rectangular filter class.

Create a rectangular shaped filter with length stop, height 1 (unless normalized) with indices < start set to 0.

Parameters:	start : int Start bin of the filter. stop : int Stop bin of the filter. norm : bool, optional Normalize the area of the filter to 1.

classmethod band_bins(bins, overlap=False)[source]¶

Yields start and stop bins and normalization info for creation of rectangular filters.

Parameters:	bins : list or numpy array Crossover bins of filters. overlap : bool, optional Filters should overlap.
Yields:	start : int Start bin of the filter. stop : int Stop bin of the filter.

class madmom.audio.filters.Filterbank(data, bin_frequencies)[source]¶

Generic filterbank class.

A Filterbank is a simple numpy array enhanced with several additional attributes, e.g. number of bands.

A Filterbank has a shape of (num_bins, num_bands) and can be used to filter a spectrogram of shape (num_frames, num_bins) to (num_frames, num_bands).

Parameters:	data : numpy array, shape (num_bins, num_bands) Data of the filterbank . bin_frequencies : numpy array, shape (num_bins, ) Frequencies of the bins [Hz].

Notes

The length of bin_frequencies must be equal to the first dimension of the given data array.

classmethod from_filters(filters, bin_frequencies)[source]¶

Create a filterbank with possibly multiple filters per band.

Parameters:	filters : list (of lists) of Filters List of Filters (per band); if multiple filters per band are desired, they should be also contained in a list, resulting in a list of lists of Filters. bin_frequencies : numpy array Frequencies of the bins (needed to determine the expected size of the filterbank).
Returns:	filterbank : Filterbank instance Filterbank with respective filter elements.

num_bins¶

Number of bins.

num_bands¶

Number of bands.

corner_frequencies¶

Corner frequencies of the filter bands.

center_frequencies¶

Center frequencies of the filter bands.

fmin¶

Minimum frequency of the filterbank.

fmax¶

Maximum frequency of the filterbank.

class madmom.audio.filters.FilterbankProcessor(data, bin_frequencies)[source]¶

Generic filterbank processor class.

A FilterbankProcessor is a simple wrapper for Filterbank which adds a process() method.

See also

Filterbank

process(data)[source]¶

Filter the given data with the Filterbank.

Parameters:	data : 2D numpy array Data to be filtered. Returns ——- filt_data : numpy array Filtered data.

Notes

This method makes the Filterbank act as a Processor.

static add_arguments(parser, filterbank=None, num_bands=None, crossover_frequencies=None, fmin=None, fmax=None, norm_filters=None, unique_filters=None)[source]¶

Add filterbank related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. filterbank : audio.filters.Filterbank, optional Use a filterbank of that type. num_bands : int, optional Number of bands (per octave). crossover_frequencies : list or numpy array, optional List of crossover frequencies at which the spectrogram is split into bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

Returns:

argparse argument group Filterbank argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’. Depending on the type of the filterbank, either num_bands or crossover_frequencies should be used.

class madmom.audio.filters.MelFilterbank(bin_frequencies, num_bands=40, fmin=20.0, fmax=17000.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

Mel filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. num_bands : int, optional Number of filter bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

Notes

Because of rounding and mapping of frequencies to bins and back to frequencies, the actual minimum, maximum and center frequencies do not necessarily match the parameters given.

class madmom.audio.filters.BarkFilterbank(bin_frequencies, num_bands='normal', fmin=20.0, fmax=15500.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

Bark filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. num_bands : {‘normal’, ‘double’}, optional Number of filter bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

class madmom.audio.filters.LogarithmicFilterbank(bin_frequencies, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, bands_per_octave=True)[source]¶

Logarithmic filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. num_bands : int, optional Number of filter bands (per octave). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. bands_per_octave : bool, optional Indicates whether num_bands is given as number of bands per octave (‘True’, default) or as an absolute number of bands (‘False’).

Notes

num_bands sets either the number of bands per octave or the total number of bands, depending on the setting of bands_per_octave. num_bands is used to set also the number of bands per octave to keep the argument for all classes the same. If 12 bands per octave are used, a filterbank with semitone spacing is created.

madmom.audio.filters.LogFilterbank¶

alias of LogarithmicFilterbank

class madmom.audio.filters.RectangularFilterbank(bin_frequencies, crossover_frequencies, fmin=30.0, fmax=17000.0, norm_filters=True, unique_filters=True)[source]¶

Rectangular filterbank class.

Parameters:

bin_frequencies : numpy array Frequencies of the bins [Hz]. crossover_frequencies : list or numpy array Crossover frequencies of the bands [Hz]. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filters to area 1. unique_filters : bool, optional Keep only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

madmom.audio.comb_filters¶

This module contains comb-filter and comb-filterbank functionality.

class madmom.audio.comb_filters.CombFilterbankProcessor¶

CombFilterbankProcessor class.

Parameters:	filter_function : filter function or str Filter function to use {feed_forward_comb_filter, feed_backward_comb_filter} or a string literal {‘forward’, ‘backward’}. tau : list or numpy array, shape (N,) Delay length(s) [frames]. alpha : list or numpy array, shape (N,) Corresponding scaling factor(s).

Notes

tau and alpha must have the same length.

process(self, data)¶

Process the given data with the comb filter.

Parameters:	data : numpy array Data to be filtered/processed.
Returns:	comb_filtered_data : numpy array Comb filtered data with the different taus aligned along the (new) first dimension.

madmom.audio.comb_filters.comb_filter(signal, filter_function, tau, alpha)¶

Filter the signal with a bank of either feed forward or backward comb filters.

Parameters:	signal : numpy array Signal. filter_function : {feed_forward_comb_filter, feed_backward_comb_filter} Filter function to use (feed forward or backward). tau : list or numpy array, shape (N,) Delay length(s) [frames]. alpha : list or numpy array, shape (N,) Corresponding scaling factor(s).
Returns:	comb_filtered_signal : numpy array Comb filtered signal with the different taus aligned along the (new) first dimension.

Notes

tau and alpha must be of same length.

madmom.audio.comb_filters.feed_backward_comb_filter(signal, tau, alpha)¶

Filter the signal with a feed backward comb filter.

Parameters:	signal : numpy array Signal. tau : int Delay length. alpha : float Scaling factor.
Returns:	comb_filtered_signal : numpy array Comb filtered signal.

Notes

y[n] = x[n] + α * y[n - τ] is used as a filter function.

madmom.audio.comb_filters.feed_backward_comb_filter_1d(ndarray signal, unsigned int tau, float alpha)¶

Filter the signal with a feed backward comb filter.

Parameters:	signal : 1D numpy array, float dtype Signal. tau : int Delay length. alpha : float Scaling factor.
Returns:	comb_filtered_signal : numpy array Comb filtered signal.

Notes

y[n] = x[n] + α * y[n - τ] is used as a filter function.

madmom.audio.comb_filters.feed_backward_comb_filter_2d(ndarray signal, unsigned int tau, float alpha)¶

Filter the signal with a feed backward comb filter.

Parameters:	signal : 2D numpy array, float dtype Signal. tau : int Delay length. alpha : float Scaling factor.
Returns:	comb_filtered_signal : numpy array Comb filtered signal.

Notes

y[n] = x[n] + α * y[n - τ] is used as a filter function.

madmom.audio.comb_filters.feed_forward_comb_filter(signal, tau, alpha)¶

Filter the signal with a feed forward comb filter.

Parameters:	signal : numpy array Signal. tau : int Delay length. alpha : float Scaling factor.
Returns:	comb_filtered_signal : numpy array Comb filtered signal.

Notes

y[n] = x[n] + α * x[n - τ] is used as a filter function.

madmom.audio.ffmpeg¶

This module contains audio handling via ffmpeg functionality.

madmom.audio.ffmpeg.decode_to_disk(infile, fmt='f32le', sample_rate=None, num_channels=1, skip=None, max_len=None, outfile=None, tmp_dir=None, tmp_suffix=None, cmd='ffmpeg')[source]¶

Decodes the given audio file, optionally down-mixes it to mono and writes it to another file as a sequence of samples. Returns the file name of the output file.

Parameters:

infile : str Name of the audio sound file to decode. fmt : {‘f32le’, ‘s16le’}, optional Format of the samples: - ‘f32le’ for float32, little-endian, - ‘s16le’ for signed 16-bit int, little-endian. sample_rate : int, optional Sample rate to re-sample the signal to (if set) [Hz]. num_channels : int, optional Number of channels to reduce the signal to. skip : float, optional Number of seconds to skip at beginning of file. max_len : float, optional Maximum length in seconds to decode. outfile : str, optional The file to decode the sound file to; if not given, a temporary file will be created. tmp_dir : str, optional The directory to create the temporary file in (if no outfile is given). tmp_suffix : str, optional The file suffix for the temporary file if no outfile is given; e.g. ”.pcm” (including the dot). cmd : {‘ffmpeg’, ‘avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv).

Returns:

outfile : str The output file name.

madmom.audio.ffmpeg.decode_to_memory(infile, fmt='f32le', sample_rate=None, num_channels=1, skip=None, max_len=None, cmd='ffmpeg')[source]¶

Decodes the given audio file, down-mixes it to mono and returns it as a binary string of a sequence of samples.

Parameters:

infile : str Name of the audio sound file to decode. fmt : {‘f32le’, ‘s16le’}, optional Format of the samples: - ‘f32le’ for float32, little-endian, - ‘s16le’ for signed 16-bit int, little-endian. sample_rate : int, optional Sample rate to re-sample the signal to (if set) [Hz]. num_channels : int, optional Number of channels to reduce the signal to. skip : float, optional Number of seconds to skip at beginning of file. max_len : float, optional Maximum length in seconds to decode. cmd : {‘ffmpeg’, ‘avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv).

Returns:

samples : str a binary string of samples

madmom.audio.ffmpeg.decode_to_pipe(infile, fmt='f32le', sample_rate=None, num_channels=1, skip=None, max_len=None, buf_size=-1, cmd='ffmpeg')[source]¶

Decodes the given audio file, down-mixes it to mono and returns a file-like object for reading the samples, as well as a process object. To stop decoding the file, call close() on the returned file-like object, then call wait() on the returned process object.

Parameters:

infile : str Name of the audio sound file to decode. fmt : {‘f32le’, ‘s16le’}, optional Format of the samples: - ‘f32le’ for float32, little-endian, - ‘s16le’ for signed 16-bit int, little-endian. sample_rate : int, optional Sample rate to re-sample the signal to (if set) [Hz]. num_channels : int, optional Number of channels to reduce the signal to. skip : float, optional Number of seconds to skip at beginning of file. max_len : float, optional Maximum length in seconds to decode. buf_size : int, optional Size of buffer for the file-like object: - ‘-1’ means OS default (default), - ‘0’ means unbuffered, - ‘1’ means line-buffered, any other value is the buffer size in bytes. cmd : {‘ffmpeg’,’avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv).

Returns:

pipe : file-like object File-like object for reading the decoded samples. proc : process object Process object for the decoding process.

madmom.audio.ffmpeg.get_file_info(infile, cmd='ffprobe')[source]¶

Extract and return information about audio files.

Parameters:	infile : str Name of the audio file. cmd : {‘ffprobe’, ‘avprobe’}, optional Probing command (defaults to ffprobe, alternatively supports avprobe).
Returns:	dict Audio file information.

madmom.audio.ffmpeg.load_ffmpeg_file(filename, sample_rate=None, num_channels=None, start=None, stop=None, dtype=None, cmd_decode='ffmpeg', cmd_probe='ffprobe')[source]¶

Load the audio data from the given file and return it as a numpy array.

This uses ffmpeg (or avconv) and thus supports a lot of different file formats, resampling and channel conversions. The file will be fully decoded into memory if no start and stop positions are given.

Parameters:

filename : str Name of the audio sound file to load. sample_rate : int, optional Sample rate to re-sample the signal to [Hz]; ‘None’ returns the signal in its original rate. num_channels : int, optional Reduce or expand the signal to num_channels channels; ‘None’ returns the signal with its original channels. start : float, optional Start position [seconds]. stop : float, optional Stop position [seconds]. dtype : numpy dtype, optional Numpy dtype to return the signal in (supports signed and unsigned 8/16/32-bit integers, and single and double precision floats, each in little or big endian). If ‘None’, np.int16 is used. cmd_decode : {‘ffmpeg’, ‘avconv’}, optional Decoding command (defaults to ffmpeg, alternatively supports avconv). cmd_probe : {‘ffprobe’, ‘avprobe’}, optional Probing command (defaults to ffprobe, alternatively supports avprobe).

Returns:

signal : numpy array Audio samples. sample_rate : int Sample rate of the audio samples.

madmom.audio.stft¶

This module contains Short-Time Fourier Transform (STFT) related functionality.

madmom.audio.stft.fft_frequencies(num_fft_bins, sample_rate)[source]¶

Frequencies of the FFT bins.

Parameters:	num_fft_bins : int Number of FFT bins (i.e. half the FFT length). sample_rate : float Sample rate of the signal.
Returns:	fft_frequencies : numpy array Frequencies of the FFT bins [Hz].

madmom.audio.stft.stft(frames, window, fft_size=None, circular_shift=False)[source]¶

Calculates the complex Short-Time Fourier Transform (STFT) of the given framed signal.

Parameters:

frames : numpy array or iterable, shape (num_frames, frame_size) Framed signal (e.g. FramedSignal instance) window : numpy array, shape (frame_size,) Window (function). fft_size : int, optional FFT size (should be a power of 2); if ‘None’, the ‘frame_size’ given by the frames is used; if the given fft_size is greater than the ‘frame_size’, the frames are zero-padded accordingly. circular_shift : bool, optional Circular shift the individual frames before performing the FFT; needed for correct phase.

Returns:

stft : numpy array, shape (num_frames, frame_size) The complex STFT of the framed signal.

madmom.audio.stft.phase(stft)[source]¶

Returns the phase of the complex STFT of a signal.

Parameters:	stft : numpy array, shape (num_frames, frame_size) The complex STFT of a signal.
Returns:	phase : numpy array Phase of the STFT.

madmom.audio.stft.local_group_delay(phase)[source]¶

Returns the local group delay of the phase of a signal.

Parameters:	phase : numpy array, shape (num_frames, frame_size) Phase of the STFT of a signal.
Returns:	lgd : numpy array Local group delay of the phase.

madmom.audio.stft.lgd(phase)¶

Returns the local group delay of the phase of a signal.

Parameters:	phase : numpy array, shape (num_frames, frame_size) Phase of the STFT of a signal.
Returns:	lgd : numpy array Local group delay of the phase.

class madmom.audio.stft.PropertyMixin[source]¶

Mixin which provides num_frames, num_bins properties to classes.

num_frames¶

Number of frames.

num_bins¶

Number of bins.

class madmom.audio.stft.ShortTimeFourierTransform(frames, window=<function hanning>, fft_size=None, circular_shift=False, **kwargs)[source]¶

ShortTimeFourierTransform class.

Parameters:

frames : audio.signal.FramedSignal instance FramedSignal instance. window : numpy ufunc or numpy array, optional Window (function); if a function (e.g. np.hanning) is given, a window of the given shape of size of the frames is used. fft_size : int, optional FFT size (should be a power of 2); if ‘None’, the frame_size given by the frames is used, if the given fft_size is greater than the frame_size, the frames are zero-padded accordingly. circular_shift : bool, optional Circular shift the individual frames before performing the FFT; needed for correct phase. kwargs : dict, optional If no audio.signal.FramedSignal instance was given, one is instantiated with these additional keyword arguments.

Notes

If the Signal (wrapped in the FramedSignal) has an integer dtype, it is automatically scaled as if it has a float dtype with the values being in the range [-1, 1]. This results in same valued STFTs independently of the dtype of the signal. On the other hand, this prevents extra memory consumption since the data-type of the signal does not need to be converted (and if no decoding is needed, the audio signal can be memory mapped).

spec(**kwargs)[source]¶

Returns the magnitude spectrogram of the STFT.

Parameters:	kwargs : dict, optional Keyword arguments passed to audio.spectrogram.Spectrogram.
Returns:	spec : audio.spectrogram.Spectrogram audio.spectrogram.Spectrogram instance.

phase(**kwargs)[source]¶

Returns the phase of the STFT.

Parameters:	kwargs : dict, optional keyword arguments passed to Phase.
Returns:	phase : Phase Phase instance.

madmom.audio.stft.STFT¶

alias of ShortTimeFourierTransform

class madmom.audio.stft.ShortTimeFourierTransformProcessor(window=<function hanning>, fft_size=None, circular_shift=False, **kwargs)[source]¶

ShortTimeFourierTransformProcessor class.

Parameters:	window : numpy ufunc, optional Window function. fft_size : int, optional FFT size (should be a power of 2); if ‘None’, it is determined by the size of the frames; if is greater than the frame size, the frames are zero-padded accordingly. circular_shift : bool, optional Circular shift the individual frames before performing the FFT; needed for correct phase.

process(data, **kwargs)[source]¶

Perform FFT on a framed signal and return the STFT.

Parameters:	data : numpy array Data to be processed. kwargs : dict, optional Keyword arguments passed to ShortTimeFourierTransform.
Returns:	stft : ShortTimeFourierTransform ShortTimeFourierTransform instance.

static add_arguments(parser, window=None, fft_size=None)[source]¶

Add STFT related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser. window : numpy ufunc, optional Window function. fft_size : int, optional Use this size for FFT (should be a power of 2).
Returns:	argpase argument group STFT argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

madmom.audio.stft.STFTProcessor¶

alias of ShortTimeFourierTransformProcessor

class madmom.audio.stft.Phase(stft, **kwargs)[source]¶

Phase class.

Parameters:	stft : ShortTimeFourierTransform instance ShortTimeFourierTransform instance. kwargs : dict, optional If no ShortTimeFourierTransform instance was given, one is instantiated with these additional keyword arguments.

local_group_delay(**kwargs)[source]¶

Returns the local group delay of the phase.

Parameters:	kwargs : dict, optional Keyword arguments passed to LocalGroupDelay.
Returns:	lgd : LocalGroupDelay instance LocalGroupDelay instance.

lgd(**kwargs)¶

Returns the local group delay of the phase.

Parameters:	kwargs : dict, optional Keyword arguments passed to LocalGroupDelay.
Returns:	lgd : LocalGroupDelay instance LocalGroupDelay instance.

class madmom.audio.stft.LocalGroupDelay(phase, **kwargs)[source]¶

Local Group Delay class.

Parameters:	stft : Phase instance Phase instance. kwargs : dict, optional If no Phase instance was given, one is instantiated with these additional keyword arguments.

madmom.audio.stft.LGD¶

alias of LocalGroupDelay

madmom.audio.spectrogram¶

This module contains spectrogram related functionality.

madmom.audio.spectrogram.spec(stft)[source]¶

Computes the magnitudes of the complex Short Time Fourier Transform of a signal.

Parameters:	stft : numpy array Complex STFT of a signal.
Returns:	spec : numpy array Magnitude spectrogram.

class madmom.audio.spectrogram.Spectrogram(stft, **kwargs)[source]¶

A Spectrogram represents the magnitude spectrogram of a audio.stft.ShortTimeFourierTransform.

Parameters:	stft : audio.stft.ShortTimeFourierTransform instance Short Time Fourier Transform. kwargs : dict, optional If no audio.stft.ShortTimeFourierTransform instance was given, one is instantiated with these additional keyword arguments.

Attributes

stft	(audio.stft.ShortTimeFourierTransform instance) Underlying ShortTimeFourierTransform instance.
frames	(audio.signal.FramedSignal instance) Underlying FramedSignal instance.

diff(**kwargs)[source]¶

Return the difference of the magnitude spectrogram.

Parameters:	kwargs : dict Keyword arguments passed to SpectrogramDifference.
Returns:	diff : SpectrogramDifference instance The differences of the magnitude spectrogram.

filter(**kwargs)[source]¶

Return a filtered version of the magnitude spectrogram.

Parameters:	kwargs : dict Keyword arguments passed to FilteredSpectrogram.
Returns:	filt_spec : FilteredSpectrogram instance Filtered version of the magnitude spectrogram.

log(**kwargs)[source]¶

Return a logarithmically scaled version of the magnitude spectrogram.

Parameters:	kwargs : dict Keyword arguments passed to LogarithmicSpectrogram.
Returns:	log_spec : LogarithmicSpectrogram instance Logarithmically scaled version of the magnitude spectrogram.

class madmom.audio.spectrogram.SpectrogramProcessor(**kwargs)[source]¶

SpectrogramProcessor class.

process(data, **kwargs)[source]¶

Create a Spectrogram from the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to Spectrogram.
Returns:	spec : Spectrogram instance Spectrogram.

class madmom.audio.spectrogram.FilteredSpectrogram(spectrogram, filterbank=<class 'madmom.audio.filters.LogarithmicFilterbank'>, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

FilteredSpectrogram class.

Parameters:

spectrogram : Spectrogram instance Spectrogram. filterbank : audio.filters.Filterbank, optional Filterbank class or instance; if a class is given (rather than an instance), one will be created with the given type and parameters. num_bands : int, optional Number of filter bands (per octave, depending on the type of the filterbank). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter bands of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

class madmom.audio.spectrogram.FilteredSpectrogramProcessor(filterbank=<class 'madmom.audio.filters.LogarithmicFilterbank'>, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

FilteredSpectrogramProcessor class.

Parameters:

filterbank : audio.filters.Filterbank Filterbank used to filter a spectrogram. num_bands : int Number of bands (per octave). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

process(data, **kwargs)[source]¶

Create a FilteredSpectrogram from the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to FilteredSpectrogram.
Returns:	filt_spec : FilteredSpectrogram instance Filtered spectrogram.

class madmom.audio.spectrogram.LogarithmicSpectrogram(spectrogram, mul=1.0, add=1.0, **kwargs)[source]¶

LogarithmicSpectrogram class.

Parameters:	spectrogram : Spectrogram instance Spectrogram. mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

class madmom.audio.spectrogram.LogarithmicSpectrogramProcessor(mul=1.0, add=1.0, **kwargs)[source]¶

Logarithmic Spectrogram Processor class.

Parameters:	mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes.

process(data, **kwargs)[source]¶

Perform logarithmic scaling of a spectrogram.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to LogarithmicSpectrogram.
Returns:	log_spec : LogarithmicSpectrogram instance Logarithmically scaled spectrogram.

static add_arguments(parser, log=None, mul=None, add=None)[source]¶

Add spectrogram scaling related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser object. log : bool, optional Take the logarithm of the spectrogram. mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes.
Returns:	argparse argument group Spectrogram scaling argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

class madmom.audio.spectrogram.LogarithmicFilteredSpectrogram(spectrogram, **kwargs)[source]¶

LogarithmicFilteredSpectrogram class.

Parameters:	spectrogram : FilteredSpectrogram instance Filtered spectrogram. kwargs : dict, optional If no FilteredSpectrogram instance was given, one is instantiated with these additional keyword arguments and logarithmically scaled afterwards, i.e. passed to LogarithmicSpectrogram.

See also

FilteredSpectrogram, LogarithmicSpectrogram

Notes

For the filtering and scaling parameters, please refer to FilteredSpectrogram and LogarithmicSpectrogram.

class madmom.audio.spectrogram.LogarithmicFilteredSpectrogramProcessor(filterbank=<class 'madmom.audio.filters.LogarithmicFilterbank'>, num_bands=12, fmin=30.0, fmax=17000.0, fref=440.0, norm_filters=True, unique_filters=True, mul=1.0, add=1.0, **kwargs)[source]¶

Logarithmic Filtered Spectrogram Processor class.

Parameters:

filterbank : audio.filters.Filterbank Filterbank used to filter a spectrogram. num_bands : int Number of bands (per octave). fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. fref : float, optional Tuning frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. mul : float, optional Multiply the magnitude spectrogram with this factor before taking the logarithm. add : float, optional Add this value before taking the logarithm of the magnitudes.

process(data, **kwargs)[source]¶

Perform filtering and logarithmic scaling of a spectrogram.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to LogarithmicFilteredSpectrogram.
Returns:	log_filt_spec : LogarithmicFilteredSpectrogram instance Logarithmically scaled filtered spectrogram.

class madmom.audio.spectrogram.SpectrogramDifference(spectrogram, diff_ratio=0.5, diff_frames=None, diff_max_bins=None, positive_diffs=False, **kwargs)[source]¶

SpectrogramDifference class.

Parameters:

spectrogram : Spectrogram instance Spectrogram. diff_ratio : float, optional Calculate the difference to the frame at which the window used for the STFT yields this ratio of the maximum height. diff_frames : int, optional Calculate the difference to the diff_frames-th previous frame (if set, this overrides the value calculated from the diff_ratio) diff_max_bins : int, optional Apply a maximum filter with this width (in bins in frequency dimension) to the spectrogram the difference is calculated to. positive_diffs : bool, optional Keep only the positive differences, i.e. set all diff values < 0 to 0. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

Notes

The SuperFlux algorithm [R1] uses a maximum filtered spectrogram with 3 diff_max_bins together with a 24 band logarithmic filterbank to calculate the difference spectrogram with a diff_ratio of 0.5.

The effect of this maximum filter applied to the spectrogram is that the magnitudes are “widened” in frequency direction, i.e. the following difference calculation is less sensitive against frequency fluctuations. This effect is exploitet to suppress false positive energy fragments for onsets detection originating from vibrato.

References

[R1]	(1, 2) Sebastian Böck and Gerhard Widmer “Maximum Filter Vibrato Suppression for Onset Detection” Proceedings of the 16th International Conference on Digital Audio Effects (DAFx), 2013.

positive_diff()[source]¶

Positive diff.

class madmom.audio.spectrogram.SpectrogramDifferenceProcessor(diff_ratio=0.5, diff_frames=None, diff_max_bins=None, positive_diffs=False, stack_diffs=None, **kwargs)[source]¶

Difference Spectrogram Processor class.

Parameters:

diff_ratio : float, optional Calculate the difference to the frame at which the window used for the STFT yields this ratio of the maximum height. diff_frames : int, optional Calculate the difference to the diff_frames-th previous frame (if set, this overrides the value calculated from the diff_ratio) diff_max_bins : int, optional Apply a maximum filter with this width (in bins in frequency dimension) to the spectrogram the difference is calculated to. positive_diffs : bool, optional Keep only the positive differences, i.e. set all diff values < 0 to 0. stack_diffs : numpy stacking function, optional If ‘None’, only the differences are returned. If set, the diffs are stacked with the underlying spectrogram data according to the stack function: np.vstack the differences and spectrogram are stacked vertically, i.e. in time direction, np.hstack the differences and spectrogram are stacked horizontally, i.e. in frequency direction, np.dstack the differences and spectrogram are stacked in depth, i.e. return them as a 3D representation with depth as the third dimension.

process(data, **kwargs)[source]¶

Perform a temporal difference calculation on the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to SpectrogramDifference.
Returns:	diff : SpectrogramDifference instance Spectrogram difference.

static add_arguments(parser, diff=None, diff_ratio=None, diff_frames=None, diff_max_bins=None, positive_diffs=None)[source]¶

Add spectrogram difference related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. diff : bool, optional Take the difference of the spectrogram. diff_ratio : float, optional Calculate the difference to the frame at which the window used for the STFT yields this ratio of the maximum height. diff_frames : int, optional Calculate the difference to the diff_frames-th previous frame (if set, this overrides the value calculated from the diff_ratio) diff_max_bins : int, optional Apply a maximum filter with this width (in bins in frequency dimension) to the spectrogram the difference is calculated to. positive_diffs : bool, optional Keep only the positive differences, i.e. set all diff values < 0 to 0.

Returns:

argparse argument group Spectrogram difference argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

Only the diff_frames parameter behaves differently, it is included if either the diff_ratio is set or a value != ‘None’ is given.

class madmom.audio.spectrogram.SuperFluxProcessor(**kwargs)[source]¶

Spectrogram processor which sets the default values suitable for the SuperFlux algorithm.

class madmom.audio.spectrogram.MultiBandSpectrogram(spectrogram, crossover_frequencies, fmin=30.0, fmax=17000.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

MultiBandSpectrogram class.

Parameters:

spectrogram : Spectrogram instance Spectrogram. crossover_frequencies : list or numpy array List of crossover frequencies at which the spectrogram is split into multiple bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter bands of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies. kwargs : dict, optional If no Spectrogram instance was given, one is instantiated with these additional keyword arguments.

Notes

The MultiBandSpectrogram is implemented as a Spectrogram which uses a audio.filters.RectangularFilterbank to combine multiple frequency bins.

class madmom.audio.spectrogram.MultiBandSpectrogramProcessor(crossover_frequencies, fmin=30.0, fmax=17000.0, norm_filters=True, unique_filters=True, **kwargs)[source]¶

Spectrogram processor which combines the spectrogram magnitudes into multiple bands.

Parameters:

crossover_frequencies : list or numpy array List of crossover frequencies at which a spectrogram is split into the individual bands. fmin : float, optional Minimum frequency of the filterbank [Hz]. fmax : float, optional Maximum frequency of the filterbank [Hz]. norm_filters : bool, optional Normalize the filter bands of the filterbank to area 1. unique_filters : bool, optional Indicate if the filterbank should contain only unique filters, i.e. remove duplicate filters resulting from insufficient resolution at low frequencies.

process(data, **kwargs)[source]¶

Return the a multi-band representation of the given data.

Parameters:	data : numpy array Data to be processed. kwargs : dict Keyword arguments passed to MultiBandSpectrogram.
Returns:	multi_band_spec : MultiBandSpectrogram instance Spectrogram split into multiple bands.

class madmom.audio.spectrogram.StackedSpectrogramProcessor[source]¶

Deprecated in v0.13, will be removed in v0.14.

Functionality added to SpectrogramDifferenceProcessor as stack_diffs argument.

madmom.features.beats¶

This module contains beat tracking related functionality.

class madmom.features.beats.MultiModelSelectionProcessor(num_ref_predictions, **kwargs)[source]¶

Processor for selecting the most suitable model (i.e. the predictions thereof) from a multiple models/predictions.

Parameters:	num_ref_predictions : int Number of reference predictions (see below).

Notes

This processor selects the most suitable prediction from multiple models by comparing them to the predictions of a reference model. The one with the smallest mean squared error is chosen.

If num_ref_predictions is 0 or None, an averaged prediction is computed from the given predictions and used as reference.

References

[R13]

Sebastian Böck, Florian Krebs and Gerhard Widmer, “A Multi-Model Approach to Beat Tracking Considering Heterogeneous Music Styles”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2014.

process(predictions)[source]¶

Selects the most appropriate predictions form the list of predictions.

Parameters:	predictions : list Predictions (beat activation functions) of multiple models.
Returns:	numpy array Most suitable prediction.

Notes

The reference beat activation function must be the first one in the list of given predictions.

madmom.features.beats.detect_beats(activations, interval, look_aside=0.2)[source]¶

Detects the beats in the given activation function as in [R14].

Parameters:	activations : numpy array Beat activations. interval : int Look for the next beat each interval frames. look_aside : float Look this fraction of the interval to each side to detect the beats.
Returns:	numpy array Beat positions [frames].

Notes

A Hamming window of 2 * look_aside * interval is applied around the position where the beat is expected to prefer beats closer to the centre.

References

[R14]

(1, 2) Sebastian Böck and Markus Schedl, “Enhanced Beat Tracking with Context-Aware Neural Networks”, Proceedings of the 14th International Conference on Digital Audio Effects (DAFx), 2011.

class madmom.features.beats.BeatTrackingProcessor(look_aside=0.2, look_ahead=10, fps=None, **kwargs)[source]¶

Track the beats according to previously determined (local) tempo by iteratively aligning them around the estimated position [R15].

Parameters:	look_aside : float, optional Look this fraction of the estimated beat interval to each side of the assumed next beat position to look for the most likely position of the next beat. look_ahead : float, optional Look look_ahead seconds in both directions to determine the local tempo and align the beats accordingly. fps : float, optional Frames per second.

Notes

If look_ahead is not set, a constant tempo throughout the whole piece is assumed. If look_ahead is set, the local tempo (in a range +/- look_ahead seconds around the actual position) is estimated and then the next beat is tracked accordingly. This procedure is repeated from the new position to the end of the piece.

Instead of the auto-correlation based method for tempo estimation proposed in [R15], it uses a comb filter based method [R16] per default. The behaviour can be controlled with the tempo_method parameter.

References

[R15]

(1, 2, 3) Sebastian Böck and Markus Schedl, “Enhanced Beat Tracking with Context-Aware Neural Networks”, Proceedings of the 14th International Conference on Digital Audio Effects (DAFx), 2011.

[R16]

(1, 2) Sebastian Böck, Florian Krebs and Gerhard Widmer, “Accurate Tempo Estimation based on Recurrent Neural Networks and Resonating Comb Filters”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

process(activations)[source]¶

Detect the beats in the given activation function.

Parameters:	activations : numpy array Beat activation function. Returns ——- beats : numpy array Detected beat positions [seconds].

static add_arguments(parser, look_aside=0.2, look_ahead=10)[source]¶

Add beat tracking related arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser object. look_aside : float, optional Look this fraction of the estimated beat interval to each side of the assumed next beat position to look for the most likely position of the next beat. look_ahead : float, optional Look look_ahead seconds in both directions to determine the local tempo and align the beats accordingly.
Returns:	parser_group : argparse argument group Beat tracking argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.

class madmom.features.beats.BeatDetectionProcessor(look_aside=0.2, fps=None, **kwargs)[source]¶

Class for detecting beats according to the previously determined global tempo by iteratively aligning them around the estimated position [R18].

Parameters:	look_aside : float Look this fraction of the estimated beat interval to each side of the assumed next beat position to look for the most likely position of the next beat. fps : float, optional Frames per second.

See also

BeatTrackingProcessor

Notes

A constant tempo throughout the whole piece is assumed.

Instead of the auto-correlation based method for tempo estimation proposed in [R18], it uses a comb filter based method [R19] per default. The behaviour can be controlled with the tempo_method parameter.

References

[R18]

(1, 2, 3) Sebastian Böck and Markus Schedl, “Enhanced Beat Tracking with Context-Aware Neural Networks”, Proceedings of the 14th International Conference on Digital Audio Effects (DAFx), 2011.

[R19]

(1, 2) Sebastian Böck, Florian Krebs and Gerhard Widmer, “Accurate Tempo Estimation based on Recurrent Neural Networks and Resonating Comb Filters”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

class madmom.features.beats.CRFBeatDetectionProcessor(interval_sigma=0.18, use_factors=False, num_intervals=5, factors=array([ 0.5, 0.67, 1., 1.5, 2. ]), **kwargs)[source]¶

Conditional Random Field Beat Detection.

Tracks the beats according to the previously determined global tempo using a conditional random field (CRF) model.

Parameters:	interval_sigma : float, optional Allowed deviation from the dominant beat interval per beat. use_factors : bool, optional Use dominant interval multiplied by factors instead of intervals estimated by tempo estimator. num_intervals : int, optional Maximum number of estimated intervals to try. factors : list or numpy array, optional Factors of the dominant interval to try.

References

[R21]

Filip Korzeniowski, Sebastian Böck and Gerhard Widmer, “Probabilistic Extraction of Beat Positions from a Beat Activation Function”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2014.

process(activations)[source]¶

Detect the beats in the given activation function.

Parameters:	activations : numpy array Beat activation function.
Returns:	numpy array Detected beat positions [seconds].

static add_arguments(parser, interval_sigma=0.18, use_factors=False, num_intervals=5, factors=array([ 0.5, 0.67, 1., 1.5, 2. ]))[source]¶

Add CRFBeatDetection related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. interval_sigma : float, optional allowed deviation from the dominant beat interval per beat use_factors : bool, optional use dominant interval multiplied by factors instead of intervals estimated by tempo estimator num_intervals : int, optional max number of estimated intervals to try factors : list or numpy array, optional factors of the dominant interval to try

Returns:

parser_group : argparse argument group CRF beat tracking argument parser group.

class madmom.features.beats.DBNBeatTrackingProcessor(min_bpm=55.0, max_bpm=215.0, num_tempi=None, transition_lambda=100, observation_lambda=16, correct=True, fps=None, **kwargs)[source]¶

Beat tracking with RNNs and a dynamic Bayesian network (DBN) approximated by a Hidden Markov Model (HMM).

Parameters:

min_bpm : float, optional Minimum tempo used for beat tracking [bpm]. max_bpm : float, optional Maximum tempo used for beat tracking [bpm]. num_tempi : int, optional Number of tempi to model; if set, limit the number of tempi and use a log spacing, otherwise a linear spacing. transition_lambda : float, optional Lambda for the exponential tempo change distribution (higher values prefer a constant tempo from one beat to the next one). observation_lambda : int, optional Split one beat period into observation_lambda parts, the first representing beat states and the remaining non-beat states. correct : bool, optional Correct the beats (i.e. align them to the nearest peak of the beat activation function). fps : float, optional Frames per second.

Notes

Instead of the originally proposed state space and transition model for the DBN [R22], the more efficient version proposed in [R23] is used.

References

[R22]

(1, 2) Sebastian Böck, Florian Krebs and Gerhard Widmer, “A Multi-Model Approach to Beat Tracking Considering Heterogeneous Music Styles”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2014.

[R23]

(1, 2) Florian Krebs, Sebastian Böck and Gerhard Widmer, “An Efficient State Space Model for Joint Tempo and Meter Tracking”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

process(activations)[source]¶

Detect the beats in the given activation function.

Parameters:	activations : numpy array Beat activation function.
Returns:	beats : numpy array Detected beat positions [seconds].

static add_arguments(parser, min_bpm=55.0, max_bpm=215.0, num_tempi=None, transition_lambda=100, observation_lambda=16, correct=True)[source]¶

Add DBN related arguments to an existing parser object.

Parameters:

parser : argparse parser instance Existing argparse parser object. min_bpm : float, optional Minimum tempo used for beat tracking [bpm]. max_bpm : float, optional Maximum tempo used for beat tracking [bpm]. num_tempi : int, optional Number of tempi to model; if set, limit the number of tempi and use a log spacing, otherwise a linear spacing. transition_lambda : float, optional Lambda for the exponential tempo change distribution (higher values prefer a constant tempo over a tempo change from one beat to the next one). observation_lambda : int, optional Split one beat period into observation_lambda parts, the first representing beat states and the remaining non-beat states. correct : bool, optional Correct the beats (i.e. align them to the nearest peak of the beat activation function).

Returns:

parser_group : argparse argument group DBN beat tracking argument parser group

class madmom.features.beats.DownbeatTrackingProcessor[source]¶

Renamed to PatternTrackingProcessor in v0.13. Will be removed in v0.14.

class madmom.features.beats.PatternTrackingProcessor(pattern_files, min_bpm=[55, 60], max_bpm=[205, 225], num_tempi=[None, None], transition_lambda=[100, 100], downbeats=False, fps=None, **kwargs)[source]¶

Pattern tracking with a dynamic Bayesian network (DBN) approximated by a Hidden Markov Model (HMM).

Parameters:

pattern_files : list List of files with the patterns (including the fitted GMMs and information about the number of beats). min_bpm : list, optional Minimum tempi used for pattern tracking [bpm]. max_bpm : list, optional Maximum tempi used for pattern tracking [bpm]. num_tempi : int or list, optional Number of tempi to model; if set, limit the number of tempi and use a log spacings, otherwise a linear spacings. transition_lambda : float or list, optional Lambdas for the exponential tempo change distributions (higher values prefer constant tempi from one beat to the next .one) downbeats : bool, optional Report only the downbeats instead of the beats and the respective position inside the bar. fps : float, optional Frames per second.

Notes

min_bpm, max_bpm, num_tempo_states, and transition_lambda must contain as many items as rhythmic patterns are modeled (i.e. length of pattern_files). If a single value is given for num_tempo_states and transition_lambda, this value is used for all rhythmic patterns.

Instead of the originally proposed state space and transition model for the DBN [R24], the more efficient version proposed in [R25] is used.

References

[R24]

(1, 2) Florian Krebs, Sebastian Böck and Gerhard Widmer, “Rhythmic Pattern Modeling for Beat and Downbeat Tracking in Musical Audio”, Proceedings of the 15th International Society for Music Information Retrieval Conference (ISMIR), 2013.

[R25]

(1, 2) Florian Krebs, Sebastian Böck and Gerhard Widmer, “An Efficient State Space Model for Joint Tempo and Meter Tracking”, Proceedings of the 16th International Society for Music Information Retrieval Conference (ISMIR), 2015.

process(activations)[source]¶

Detect the beats based on the given activations.

Parameters:	activations : numpy array Activations (i.e. multi-band spectral features).
Returns:	beats : numpy array Detected beat positions [seconds].

static add_arguments(parser, pattern_files=None, min_bpm=[55, 60], max_bpm=[205, 225], num_tempi=[None, None], transition_lambda=[100, 100])[source]¶

Add DBN related arguments for pattern tracking to an existing parser object.

Parameters:

parser : argparse parser instance Existing argparse parser object. pattern_files : list Load the patterns from these files. min_bpm : list, optional Minimum tempi used for beat tracking [bpm]. max_bpm : list, optional Maximum tempi used for beat tracking [bpm]. num_tempi : int or list, optional Number of tempi to model; if set, limit the number of states and use log spacings, otherwise a linear spacings. transition_lambda : float or list, optional Lambdas for the exponential tempo change distribution (higher values prefer constant tempi from one beat to the next one).

Returns:

parser_group : argparse argument group Pattern tracking argument parser group

Notes

pattern_files, min_bpm, max_bpm, num_tempi, and transition_lambda must the same number of items.

madmom.features.beats_crf¶

This module contains the speed crucial Viterbi functionality for the CRFBeatDetector plus some functions computing the distributions and normalisation factors.

madmom.features.beats_hmm¶

This module contains HMM state spaces, transition and observation models used for beat and downbeat tracking.

madmom.features.notes¶

This module contains note transcription related functionality.

madmom.features.notes.load_notes(*args, **kwargs)[source]¶

Load the notes from a file.

Parameters:	filename : str or file handle Input file to load the notes from.
Returns:	numpy array Notes.

Notes

The file format must be (duration and velocity being optional):

‘note_time’ ‘MIDI_note’ [‘duration’ [‘MIDI_velocity’]]

with one note per line and individual fields separated by whitespace.

madmom.features.notes.expand_notes(notes, duration=0.6, velocity=100)[source]¶

Expand the notes to include all columns.

Parameters:	notes : numpy array, shape (num_notes, 2) Notes, one per row (column definition see notes). duration : float, optional Note duration if not defined by notes. velocity : int, optional Note velocity if not defined by notes.
Returns:	numpy array Notes (including note duration and velocity).

Notes

The note columns format must be (duration and velocity being optional):

‘note_time’ ‘MIDI_note’ [‘duration’ [‘MIDI_velocity’]]

madmom.features.notes.write_notes(notes, filename, sep='\t', fmt=None, header='')[source]¶

Write the notes to a file (as many columns as given).

Parameters:	notes : numpy array, shape (num_notes, 2) Notes, one per row (column definition see notes). filename : str or file handle Output filename or handle. sep : str, optional Separator for the fields. fmt : list, optional Format of the fields (i.e. columns, see notes) header : str, optional Header to be written (as a comment).
Returns:	numpy array Notes.

Notes

The note columns format must be (duration and velocity being optional):

‘note_time’ ‘MIDI_note’ [‘duration’ [‘MIDI_velocity’]]

madmom.features.notes.write_midi(notes, filename, duration=0.6, velocity=100)[source]¶

Write the notes to a MIDI file.

Parameters:	notes : numpy array, shape (num_notes, 2) Notes, one per row (column definition see notes). filename : str Output MIDI file. duration : float, optional Note duration if not defined by notes. velocity : int, optional Note velocity if not defined by notes.
Returns:	numpy array Notes (including note length and velocity).

Notes

The note columns format must be (duration and velocity being optional):

‘note_time’ ‘MIDI_note’ [‘duration’ [‘MIDI_velocity’]]

madmom.features.notes.write_mirex_format(notes, filename, duration=0.6)[source]¶

Write the frequencies of the notes to file (in MIREX format).

Parameters:	notes : numpy array, shape (num_notes, 2) Notes, one per row (column definition see notes). filename : str or file handle Output filename or handle. duration : float, optional Note duration if not defined by notes.
Returns:	numpy array Notes in MIREX format.

Notes

The note columns format must be (duration and velocity being optional):

‘note_time’ ‘MIDI_note’ [‘duration’ [‘MIDI_velocity’]]

The output format required by MIREX is:

‘onset_time’ ‘offset_time’ ‘note_frequency’

madmom.features.notes.note_reshaper(notes)[source]¶

Reshapes the activations produced by a RNN to have the right shape.

Parameters:	notes : numpy array Note activations.
Returns:	numpy array Reshaped array to represent the 88 MIDI notes.

madmom.features.onsets¶

This module contains onset detection related functionality.

madmom.features.onsets.wrap_to_pi(phase)[source]¶

Wrap the phase information to the range -π...π.

Parameters:	phase : numpy array Phase of the STFT.
Returns:	wrapped_phase : numpy array Wrapped phase.

madmom.features.onsets.correlation_diff(spec, diff_frames=1, pos=False, diff_bins=1)[source]¶

Calculates the difference of the magnitude spectrogram relative to the N-th previous frame shifted in frequency to achieve the highest correlation between these two frames.

Parameters:	spec : numpy array Magnitude spectrogram. diff_frames : int, optional Calculate the difference to the diff_frames-th previous frame. pos : bool, optional Keep only positive values. diff_bins : int, optional Maximum number of bins shifted for correlation calculation.
Returns:	correlation_diff : numpy array (Positive) magnitude spectrogram differences.

Notes

This function is only because of completeness, it is not intended to be actually used, since it is extremely slow. Please consider the superflux() function, since if performs equally well but much faster.

madmom.features.onsets.high_frequency_content(spectrogram)[source]¶

High Frequency Content.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance.
Returns:	high_frequency_content : numpy array High frequency content onset detection function.

References

[R35]

Paul Masri, “Computer Modeling of Sound for Transformation and Synthesis of Musical Signals”, PhD thesis, University of Bristol, 1996.

madmom.features.onsets.spectral_diff(spectrogram, diff_frames=None)[source]¶

Spectral Diff.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance. diff_frames : int, optional Number of frames to calculate the diff to.
Returns:	spectral_diff : numpy array Spectral diff onset detection function.

References

[R36]

Chris Duxbury, Mark Sandler and Matthew Davis, “A hybrid approach to musical note onset detection”, Proceedings of the 5th International Conference on Digital Audio Effects (DAFx), 2002.

madmom.features.onsets.spectral_flux(spectrogram, diff_frames=None)[source]¶

Spectral Flux.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance. diff_frames : int, optional Number of frames to calculate the diff to.
Returns:	spectral_flux : numpy array Spectral flux onset detection function.

References

[R37]

Paul Masri, “Computer Modeling of Sound for Transformation and Synthesis of Musical Signals”, PhD thesis, University of Bristol, 1996.

madmom.features.onsets.superflux(spectrogram, diff_frames=None, diff_max_bins=3)[source]¶

SuperFlux method with a maximum filter vibrato suppression stage.

Calculates the difference of bin k of the magnitude spectrogram relative to the N-th previous frame with the maximum filtered spectrogram.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance. diff_frames : int, optional Number of frames to calculate the diff to. diff_max_bins : int, optional Number of bins used for maximum filter.
Returns:	superflux : numpy array SuperFlux onset detection function.

Notes

This method works only properly, if the spectrogram is filtered with a filterbank of the right frequency spacing. Filter banks with 24 bands per octave (i.e. quarter-tone resolution) usually yield good results. With max_bins = 3, the maximum of the bins k-1, k, k+1 of the frame diff_frames to the left is used for the calculation of the difference.

References

[R38]

Sebastian Böck and Gerhard Widmer, “Maximum Filter Vibrato Suppression for Onset Detection”, Proceedings of the 16th International Conference on Digital Audio Effects (DAFx), 2013.

madmom.features.onsets.complex_flux(spectrogram, diff_frames=None, diff_max_bins=3, temporal_filter=3, temporal_origin=0)[source]¶

ComplexFlux.

ComplexFlux is based on the SuperFlux, but adds an additional local group delay based tremolo suppression.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance. diff_frames : int, optional Number of frames to calculate the diff to. diff_max_bins : int, optional Number of bins used for maximum filter. temporal_filter : int, optional Temporal maximum filtering of the local group delay [frames]. temporal_origin : int, optional Origin of the temporal maximum filter.
Returns:	complex_flux : numpy array ComplexFlux onset detection function.

References

[R39]

Sebastian Böck and Gerhard Widmer, “Local group delay based vibrato and tremolo suppression for onset detection”, Proceedings of the 14th International Society for Music Information Retrieval Conference (ISMIR), 2013.

madmom.features.onsets.modified_kullback_leibler(spectrogram, diff_frames=1, epsilon=1e-06)[source]¶

Modified Kullback-Leibler.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance. diff_frames : int, optional Number of frames to calculate the diff to. epsilon : float, optional Add epsilon to the spectrogram avoid division by 0.
Returns:	modified_kullback_leibler : numpy array MKL onset detection function.

Notes

The implementation presented in [R40] is used instead of the original work presented in [R41].

References

[R40]

(1, 2) Paul Brossier, “Automatic Annotation of Musical Audio for Interactive Applications”, PhD thesis, Queen Mary University of London, 2006.

[R41]

(1, 2) Stephen Hainsworth and Malcolm Macleod, “Onset Detection in Musical Audio Signals”, Proceedings of the International Computer Music Conference (ICMC), 2003.

madmom.features.onsets.phase_deviation(spectrogram)[source]¶

Phase Deviation.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance.
Returns:	phase_deviation : numpy array Phase deviation onset detection function.

References

[R42]

Juan Pablo Bello, Chris Duxbury, Matthew Davies and Mark Sandler, “On the use of phase and energy for musical onset detection in the complex domain”, IEEE Signal Processing Letters, Volume 11, Number 6, 2004.

madmom.features.onsets.weighted_phase_deviation(spectrogram)[source]¶

Weighted Phase Deviation.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance.
Returns:	weighted_phase_deviation : numpy array Weighted phase deviation onset detection function.

References

[R43]

Simon Dixon, “Onset Detection Revisited”, Proceedings of the 9th International Conference on Digital Audio Effects (DAFx), 2006.

madmom.features.onsets.normalized_weighted_phase_deviation(spectrogram, epsilon=1e-06)[source]¶

Normalized Weighted Phase Deviation.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance. epsilon : float, optional Add epsilon to the spectrogram avoid division by 0.
Returns:	normalized_weighted_phase_deviation : numpy array Normalized weighted phase deviation onset detection function.

References

[R44]

Simon Dixon, “Onset Detection Revisited”, Proceedings of the 9th International Conference on Digital Audio Effects (DAFx), 2006.

madmom.features.onsets.complex_domain(spectrogram)[source]¶

Complex Domain.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance.
Returns:	complex_domain : numpy array Complex domain onset detection function.

References

[R45]

Juan Pablo Bello, Chris Duxbury, Matthew Davies and Mark Sandler, “On the use of phase and energy for musical onset detection in the complex domain”, IEEE Signal Processing Letters, Volume 11, Number 6, 2004.

madmom.features.onsets.rectified_complex_domain(spectrogram, diff_frames=None)[source]¶

Rectified Complex Domain.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance. diff_frames : int, optional Number of frames to calculate the diff to.
Returns:	rectified_complex_domain : numpy array Rectified complex domain onset detection function.

References

[R46]

Simon Dixon, “Onset Detection Revisited”, Proceedings of the 9th International Conference on Digital Audio Effects (DAFx), 2006.

class madmom.features.onsets.SpectralOnsetProcessor(onset_method='superflux', **kwargs)[source]¶

The SpectralOnsetProcessor class implements most of the common onset detection functions based on the magnitude or phase information of a spectrogram.

Parameters:	onset_method : str, optional Onset detection function. See METHODS for possible values.

process(spectrogram)[source]¶

Detect the onsets in the given activation function.

Parameters:	spectrogram : Spectrogram instance Spectrogram instance.
Returns:	odf : numpy array Onset detection function.

classmethod add_arguments(parser, onset_method=None)[source]¶

Add spectral onset detection arguments to an existing parser.

Parameters:	parser : argparse parser instance Existing argparse parser object. onset_method : str, optional Default onset detection method.
Returns:	parser_group : argparse argument group Spectral onset detection argument parser group.

madmom.features.onsets.peak_picking(activations, threshold, smooth=None, pre_avg=0, post_avg=0, pre_max=1, post_max=1)[source]¶

Perform thresholding and peak-picking on the given activation function.

Parameters:

activations : numpy array Activation function. threshold : float Threshold for peak-picking smooth : int or numpy array Smooth the activation function with the kernel (size). pre_avg : int, optional Use pre_avg frames past information for moving average. post_avg : int, optional Use post_avg frames future information for moving average. pre_max : int, optional Use pre_max frames past information for moving maximum. post_max : int, optional Use post_max frames future information for moving maximum.

Returns:

peak_idx : numpy array Indices of the detected peaks.

See also

smooth()

Notes

If no moving average is needed (e.g. the activations are independent of the signal’s level as for neural network activations), set pre_avg and post_avg to 0. For peak picking of local maxima, set pre_max and post_max to 1. For online peak picking, set all post_ parameters to 0.

References

[R47]

Sebastian Böck, Florian Krebs and Markus Schedl, “Evaluating the Online Capabilities of Onset Detection Methods”, Proceedings of the 13th International Society for Music Information Retrieval Conference (ISMIR), 2012.

class madmom.features.onsets.PeakPickingProcessor(threshold=0.5, smooth=0.0, pre_avg=0.0, post_avg=0.0, pre_max=0.0, post_max=0.0, combine=0.03, delay=0.0, online=False, fps=100, **kwargs)[source]¶

This class implements the onset peak-picking functionality which can be used universally. It transparently converts the chosen values from seconds to frames.

Parameters:

threshold : float Threshold for peak-picking. smooth : float, optional Smooth the activation function over smooth seconds. pre_avg : float, optional Use pre_avg seconds past information for moving average. post_avg : float, optional Use post_avg seconds future information for moving average. pre_max : float, optional Use pre_max seconds past information for moving maximum. post_max : float, optional Use post_max seconds future information for moving maximum. combine : float, optional Only report one onset within combine seconds. delay : float, optional Report the detected onsets delay seconds delayed. online : bool, optional Use online peak-picking, i.e. no future information. fps : float, optional Frames per second used for conversion of timings.

Returns:

onsets : numpy array Detected onsets [seconds].

Notes

If no moving average is needed (e.g. the activations are independent of the signal’s level as for neural network activations), pre_avg and post_avg should be set to 0. For peak picking of local maxima, set pre_max >= 1. / fps and post_max >= 1. / fps. For online peak picking, all post_ parameters are set to 0.

References

[R48]

Sebastian Böck, Florian Krebs and Markus Schedl, “Evaluating the Online Capabilities of Onset Detection Methods”, Proceedings of the 13th International Society for Music Information Retrieval Conference (ISMIR), 2012.

process(activations)[source]¶

Detect the onsets in the given activation function.

Parameters:	activations : numpy array Onset activation function.
Returns:	onsets : numpy array Detected onsets [seconds].

static add_arguments(parser, threshold=0.5, smooth=None, pre_avg=None, post_avg=None, pre_max=None, post_max=None, combine=0.03, delay=0.0)[source]¶

Add onset peak-picking related arguments to an existing parser.

Parameters:

parser : argparse parser instance Existing argparse parser object. threshold : float Threshold for peak-picking. smooth : float, optional Smooth the activation function over smooth seconds. pre_avg : float, optional Use pre_avg seconds past information for moving average. post_avg : float, optional Use post_avg seconds future information for moving average. pre_max : float, optional Use pre_max seconds past information for moving maximum. post_max : float, optional Use post_max seconds future information for moving maximum. combine : float, optional Only report one onset within combine seconds. delay : float, optional Report the detected onsets delay seconds delayed.

Returns:

parser_group : argparse argument group Onset peak-picking argument parser group.

Notes

Parameters are included in the group only if they are not ‘None’.