| |
| |
| """Unit conversion utilities""" |
|
|
| import re |
| import numpy as np |
| from . import notation |
| from ..util.exceptions import ParameterError |
| from ..util.decorators import deprecate_positional_args |
|
|
| __all__ = [ |
| "frames_to_samples", |
| "frames_to_time", |
| "samples_to_frames", |
| "samples_to_time", |
| "time_to_samples", |
| "time_to_frames", |
| "blocks_to_samples", |
| "blocks_to_frames", |
| "blocks_to_time", |
| "note_to_hz", |
| "note_to_midi", |
| "midi_to_hz", |
| "midi_to_note", |
| "hz_to_note", |
| "hz_to_midi", |
| "hz_to_mel", |
| "hz_to_octs", |
| "mel_to_hz", |
| "octs_to_hz", |
| "A4_to_tuning", |
| "tuning_to_A4", |
| "fft_frequencies", |
| "cqt_frequencies", |
| "mel_frequencies", |
| "tempo_frequencies", |
| "fourier_tempo_frequencies", |
| "A_weighting", |
| "B_weighting", |
| "C_weighting", |
| "D_weighting", |
| "Z_weighting", |
| "frequency_weighting", |
| "multi_frequency_weighting", |
| "samples_like", |
| "times_like", |
| "midi_to_svara_h", |
| "midi_to_svara_c", |
| "note_to_svara_h", |
| "note_to_svara_c", |
| "hz_to_svara_h", |
| "hz_to_svara_c", |
| ] |
|
|
|
|
| @deprecate_positional_args |
| def frames_to_samples(frames, *, hop_length=512, n_fft=None): |
| """Converts frame indices to audio sample indices. |
| |
| Parameters |
| ---------- |
| frames : number or np.ndarray [shape=(n,)] |
| frame index or vector of frame indices |
| hop_length : int > 0 [scalar] |
| number of samples between successive frames |
| n_fft : None or int > 0 [scalar] |
| Optional: length of the FFT window. |
| If given, time conversion will include an offset of ``n_fft // 2`` |
| to counteract windowing effects when using a non-centered STFT. |
| |
| Returns |
| ------- |
| times : number or np.ndarray |
| time (in samples) of each given frame number:: |
| |
| times[i] = frames[i] * hop_length |
| |
| See Also |
| -------- |
| frames_to_time : convert frame indices to time values |
| samples_to_frames : convert sample indices to frame indices |
| |
| Examples |
| -------- |
| >>> y, sr = librosa.load(librosa.ex('choice')) |
| >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr) |
| >>> beat_samples = librosa.frames_to_samples(beats) |
| """ |
|
|
| offset = 0 |
| if n_fft is not None: |
| offset = int(n_fft // 2) |
|
|
| return (np.asanyarray(frames) * hop_length + offset).astype(int) |
|
|
|
|
| @deprecate_positional_args |
| def samples_to_frames(samples, *, hop_length=512, n_fft=None): |
| """Converts sample indices into STFT frames. |
| |
| Examples |
| -------- |
| >>> # Get the frame numbers for every 256 samples |
| >>> librosa.samples_to_frames(np.arange(0, 22050, 256)) |
| array([ 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, |
| 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13, |
| 14, 14, 15, 15, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, |
| 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, |
| 28, 28, 29, 29, 30, 30, 31, 31, 32, 32, 33, 33, 34, 34, |
| 35, 35, 36, 36, 37, 37, 38, 38, 39, 39, 40, 40, 41, 41, |
| 42, 42, 43]) |
| |
| Parameters |
| ---------- |
| samples : int or np.ndarray [shape=(n,)] |
| sample index or vector of sample indices |
| |
| hop_length : int > 0 [scalar] |
| number of samples between successive frames |
| |
| n_fft : None or int > 0 [scalar] |
| Optional: length of the FFT window. |
| If given, time conversion will include an offset of ``- n_fft // 2`` |
| to counteract windowing effects in STFT. |
| |
| .. note:: This may result in negative frame indices. |
| |
| Returns |
| ------- |
| frames : int or np.ndarray [shape=(n,), dtype=int] |
| Frame numbers corresponding to the given times:: |
| |
| frames[i] = floor( samples[i] / hop_length ) |
| |
| See Also |
| -------- |
| samples_to_time : convert sample indices to time values |
| frames_to_samples : convert frame indices to sample indices |
| """ |
|
|
| offset = 0 |
| if n_fft is not None: |
| offset = int(n_fft // 2) |
|
|
| samples = np.asanyarray(samples) |
| return np.floor((samples - offset) // hop_length).astype(int) |
|
|
|
|
| @deprecate_positional_args |
| def frames_to_time(frames, *, sr=22050, hop_length=512, n_fft=None): |
| """Converts frame counts to time (seconds). |
| |
| Parameters |
| ---------- |
| frames : np.ndarray [shape=(n,)] |
| frame index or vector of frame indices |
| sr : number > 0 [scalar] |
| audio sampling rate |
| hop_length : int > 0 [scalar] |
| number of samples between successive frames |
| n_fft : None or int > 0 [scalar] |
| Optional: length of the FFT window. |
| If given, time conversion will include an offset of ``n_fft // 2`` |
| to counteract windowing effects when using a non-centered STFT. |
| |
| Returns |
| ------- |
| times : np.ndarray [shape=(n,)] |
| time (in seconds) of each given frame number:: |
| |
| times[i] = frames[i] * hop_length / sr |
| |
| See Also |
| -------- |
| time_to_frames : convert time values to frame indices |
| frames_to_samples : convert frame indices to sample indices |
| |
| Examples |
| -------- |
| >>> y, sr = librosa.load(librosa.ex('choice')) |
| >>> tempo, beats = librosa.beat.beat_track(y=y, sr=sr) |
| >>> beat_times = librosa.frames_to_time(beats, sr=sr) |
| """ |
|
|
| samples = frames_to_samples(frames, hop_length=hop_length, n_fft=n_fft) |
|
|
| return samples_to_time(samples, sr=sr) |
|
|
|
|
| @deprecate_positional_args |
| def time_to_frames(times, *, sr=22050, hop_length=512, n_fft=None): |
| """Converts time stamps into STFT frames. |
| |
| Parameters |
| ---------- |
| times : np.ndarray [shape=(n,)] |
| time (in seconds) or vector of time values |
| |
| sr : number > 0 [scalar] |
| audio sampling rate |
| |
| hop_length : int > 0 [scalar] |
| number of samples between successive frames |
| |
| n_fft : None or int > 0 [scalar] |
| Optional: length of the FFT window. |
| If given, time conversion will include an offset of ``- n_fft // 2`` |
| to counteract windowing effects in STFT. |
| |
| .. note:: This may result in negative frame indices. |
| |
| Returns |
| ------- |
| frames : np.ndarray [shape=(n,), dtype=int] |
| Frame numbers corresponding to the given times:: |
| |
| frames[i] = floor( times[i] * sr / hop_length ) |
| |
| See Also |
| -------- |
| frames_to_time : convert frame indices to time values |
| time_to_samples : convert time values to sample indices |
| |
| Examples |
| -------- |
| Get the frame numbers for every 100ms |
| |
| >>> librosa.time_to_frames(np.arange(0, 1, 0.1), |
| ... sr=22050, hop_length=512) |
| array([ 0, 4, 8, 12, 17, 21, 25, 30, 34, 38]) |
| |
| """ |
|
|
| samples = time_to_samples(times, sr=sr) |
|
|
| return samples_to_frames(samples, hop_length=hop_length, n_fft=n_fft) |
|
|
|
|
| @deprecate_positional_args |
| def time_to_samples(times, *, sr=22050): |
| """Convert timestamps (in seconds) to sample indices. |
| |
| Parameters |
| ---------- |
| times : number or np.ndarray |
| Time value or array of time values (in seconds) |
| sr : number > 0 |
| Sampling rate |
| |
| Returns |
| ------- |
| samples : int or np.ndarray [shape=times.shape, dtype=int] |
| Sample indices corresponding to values in ``times`` |
| |
| See Also |
| -------- |
| time_to_frames : convert time values to frame indices |
| samples_to_time : convert sample indices to time values |
| |
| Examples |
| -------- |
| >>> librosa.time_to_samples(np.arange(0, 1, 0.1), sr=22050) |
| array([ 0, 2205, 4410, 6615, 8820, 11025, 13230, 15435, |
| 17640, 19845]) |
| |
| """ |
|
|
| return (np.asanyarray(times) * sr).astype(int) |
|
|
|
|
| @deprecate_positional_args |
| def samples_to_time(samples, *, sr=22050): |
| """Convert sample indices to time (in seconds). |
| |
| Parameters |
| ---------- |
| samples : np.ndarray |
| Sample index or array of sample indices |
| sr : number > 0 |
| Sampling rate |
| |
| Returns |
| ------- |
| times : np.ndarray [shape=samples.shape] |
| Time values corresponding to ``samples`` (in seconds) |
| |
| See Also |
| -------- |
| samples_to_frames : convert sample indices to frame indices |
| time_to_samples : convert time values to sample indices |
| |
| Examples |
| -------- |
| Get timestamps corresponding to every 512 samples |
| |
| >>> librosa.samples_to_time(np.arange(0, 22050, 512)) |
| array([ 0. , 0.023, 0.046, 0.07 , 0.093, 0.116, 0.139, |
| 0.163, 0.186, 0.209, 0.232, 0.255, 0.279, 0.302, |
| 0.325, 0.348, 0.372, 0.395, 0.418, 0.441, 0.464, |
| 0.488, 0.511, 0.534, 0.557, 0.58 , 0.604, 0.627, |
| 0.65 , 0.673, 0.697, 0.72 , 0.743, 0.766, 0.789, |
| 0.813, 0.836, 0.859, 0.882, 0.906, 0.929, 0.952, |
| 0.975, 0.998]) |
| """ |
|
|
| return np.asanyarray(samples) / float(sr) |
|
|
|
|
| @deprecate_positional_args |
| def blocks_to_frames(blocks, *, block_length): |
| """Convert block indices to frame indices |
| |
| Parameters |
| ---------- |
| blocks : np.ndarray |
| Block index or array of block indices |
| block_length : int > 0 |
| The number of frames per block |
| |
| Returns |
| ------- |
| frames : np.ndarray [shape=samples.shape, dtype=int] |
| The index or indices of frames corresponding to the beginning |
| of each provided block. |
| |
| See Also |
| -------- |
| blocks_to_samples |
| blocks_to_time |
| |
| Examples |
| -------- |
| Get frame indices for each block in a stream |
| |
| >>> filename = librosa.ex('brahms') |
| >>> sr = librosa.get_samplerate(filename) |
| >>> stream = librosa.stream(filename, block_length=16, |
| ... frame_length=2048, hop_length=512) |
| >>> for n, y in enumerate(stream): |
| ... n_frame = librosa.blocks_to_frames(n, block_length=16) |
| |
| """ |
| return block_length * np.asanyarray(blocks) |
|
|
|
|
| @deprecate_positional_args |
| def blocks_to_samples(blocks, *, block_length, hop_length): |
| """Convert block indices to sample indices |
| |
| Parameters |
| ---------- |
| blocks : np.ndarray |
| Block index or array of block indices |
| block_length : int > 0 |
| The number of frames per block |
| hop_length : int > 0 |
| The number of samples to advance between frames |
| |
| Returns |
| ------- |
| samples : np.ndarray [shape=samples.shape, dtype=int] |
| The index or indices of samples corresponding to the beginning |
| of each provided block. |
| |
| Note that these correspond to the *first* sample index in |
| each block, and are not frame-centered. |
| |
| See Also |
| -------- |
| blocks_to_frames |
| blocks_to_time |
| |
| Examples |
| -------- |
| Get sample indices for each block in a stream |
| |
| >>> filename = librosa.ex('brahms') |
| >>> sr = librosa.get_samplerate(filename) |
| >>> stream = librosa.stream(filename, block_length=16, |
| ... frame_length=2048, hop_length=512) |
| >>> for n, y in enumerate(stream): |
| ... n_sample = librosa.blocks_to_samples(n, block_length=16, |
| ... hop_length=512) |
| |
| """ |
| frames = blocks_to_frames(blocks, block_length=block_length) |
| return frames_to_samples(frames, hop_length=hop_length) |
|
|
|
|
| @deprecate_positional_args |
| def blocks_to_time(blocks, *, block_length, hop_length, sr): |
| """Convert block indices to time (in seconds) |
| |
| Parameters |
| ---------- |
| blocks : np.ndarray |
| Block index or array of block indices |
| block_length : int > 0 |
| The number of frames per block |
| hop_length : int > 0 |
| The number of samples to advance between frames |
| sr : int > 0 |
| The sampling rate (samples per second) |
| |
| Returns |
| ------- |
| times : np.ndarray [shape=samples.shape] |
| The time index or indices (in seconds) corresponding to the |
| beginning of each provided block. |
| |
| Note that these correspond to the time of the *first* sample |
| in each block, and are not frame-centered. |
| |
| See Also |
| -------- |
| blocks_to_frames |
| blocks_to_samples |
| |
| Examples |
| -------- |
| Get time indices for each block in a stream |
| |
| >>> filename = librosa.ex('brahms') |
| >>> sr = librosa.get_samplerate(filename) |
| >>> stream = librosa.stream(filename, block_length=16, |
| ... frame_length=2048, hop_length=512) |
| >>> for n, y in enumerate(stream): |
| ... n_time = librosa.blocks_to_time(n, block_length=16, |
| ... hop_length=512, sr=sr) |
| |
| """ |
| samples = blocks_to_samples( |
| blocks, block_length=block_length, hop_length=hop_length |
| ) |
| return samples_to_time(samples, sr=sr) |
|
|
|
|
| def note_to_hz(note, **kwargs): |
| """Convert one or more note names to frequency (Hz) |
| |
| Examples |
| -------- |
| >>> # Get the frequency of a note |
| >>> librosa.note_to_hz('C') |
| array([ 16.352]) |
| >>> # Or multiple notes |
| >>> librosa.note_to_hz(['A3', 'A4', 'A5']) |
| array([ 220., 440., 880.]) |
| >>> # Or notes with tuning deviations |
| >>> librosa.note_to_hz('C2-32', round_midi=False) |
| array([ 64.209]) |
| |
| Parameters |
| ---------- |
| note : str or iterable of str |
| One or more note names to convert |
| **kwargs : additional keyword arguments |
| Additional parameters to `note_to_midi` |
| |
| Returns |
| ------- |
| frequencies : number or np.ndarray [shape=(len(note),)] |
| Array of frequencies (in Hz) corresponding to ``note`` |
| |
| See Also |
| -------- |
| midi_to_hz |
| note_to_midi |
| hz_to_note |
| """ |
| return midi_to_hz(note_to_midi(note, **kwargs)) |
|
|
|
|
| @deprecate_positional_args |
| def note_to_midi(note, *, round_midi=True): |
| """Convert one or more spelled notes to MIDI number(s). |
| |
| Notes may be spelled out with optional accidentals or octave numbers. |
| |
| The leading note name is case-insensitive. |
| |
| Sharps are indicated with ``#``, flats may be indicated with ``!`` or ``b``. |
| |
| Parameters |
| ---------- |
| note : str or iterable of str |
| One or more note names. |
| round_midi : bool |
| - If ``True``, allow for fractional midi notes |
| - Otherwise, round cent deviations to the nearest note |
| |
| Returns |
| ------- |
| midi : float or np.array |
| Midi note numbers corresponding to inputs. |
| |
| Raises |
| ------ |
| ParameterError |
| If the input is not in valid note format |
| |
| See Also |
| -------- |
| midi_to_note |
| note_to_hz |
| |
| Examples |
| -------- |
| >>> librosa.note_to_midi('C') |
| 12 |
| >>> librosa.note_to_midi('C#3') |
| 49 |
| >>> librosa.note_to_midi('C♯3') # Using Unicode sharp |
| 49 |
| >>> librosa.note_to_midi('C♭3') # Using Unicode flat |
| 47 |
| >>> librosa.note_to_midi('f4') |
| 65 |
| >>> librosa.note_to_midi('Bb-1') |
| 10 |
| >>> librosa.note_to_midi('A!8') |
| 116 |
| >>> librosa.note_to_midi('G𝄪6') # Double-sharp |
| 93 |
| >>> librosa.note_to_midi('B𝄫6') # Double-flat |
| 93 |
| >>> librosa.note_to_midi('C♭𝄫5') # Triple-flats also work |
| 69 |
| >>> # Lists of notes also work |
| >>> librosa.note_to_midi(['C', 'E', 'G']) |
| array([12, 16, 19]) |
| """ |
|
|
| if not isinstance(note, str): |
| return np.array([note_to_midi(n, round_midi=round_midi) for n in note]) |
|
|
| pitch_map = {"C": 0, "D": 2, "E": 4, "F": 5, "G": 7, "A": 9, "B": 11} |
| acc_map = { |
| "#": 1, |
| "": 0, |
| "b": -1, |
| "!": -1, |
| "♯": 1, |
| "𝄪": 2, |
| "♭": -1, |
| "𝄫": -2, |
| "♮": 0, |
| } |
|
|
| match = re.match( |
| r"^(?P<note>[A-Ga-g])" |
| r"(?P<accidental>[#♯𝄪b!♭𝄫♮]*)" |
| r"(?P<octave>[+-]?\d+)?" |
| r"(?P<cents>[+-]\d+)?$", |
| note, |
| ) |
| if not match: |
| raise ParameterError("Improper note format: {:s}".format(note)) |
|
|
| pitch = match.group("note").upper() |
| offset = np.sum([acc_map[o] for o in match.group("accidental")]) |
| octave = match.group("octave") |
| cents = match.group("cents") |
|
|
| if not octave: |
| octave = 0 |
| else: |
| octave = int(octave) |
|
|
| if not cents: |
| cents = 0 |
| else: |
| cents = int(cents) * 1e-2 |
|
|
| note_value = 12 * (octave + 1) + pitch_map[pitch] + offset + cents |
|
|
| if round_midi: |
| note_value = int(np.round(note_value)) |
|
|
| return note_value |
|
|
|
|
| @deprecate_positional_args |
| def midi_to_note(midi, *, octave=True, cents=False, key="C:maj", unicode=True): |
| """Convert one or more MIDI numbers to note strings. |
| |
| MIDI numbers will be rounded to the nearest integer. |
| |
| Notes will be of the format 'C0', 'C♯0', 'D0', ... |
| |
| Examples |
| -------- |
| >>> librosa.midi_to_note(0) |
| 'C-1' |
| |
| >>> librosa.midi_to_note(37) |
| 'C♯2' |
| |
| >>> librosa.midi_to_note(37, unicode=False) |
| 'C#2' |
| |
| >>> librosa.midi_to_note(-2) |
| 'A♯-2' |
| |
| >>> librosa.midi_to_note(104.7) |
| 'A7' |
| |
| >>> librosa.midi_to_note(104.7, cents=True) |
| 'A7-30' |
| |
| >>> librosa.midi_to_note(list(range(12, 24))) |
| ['C0', 'C♯0', 'D0', 'D♯0', 'E0', 'F0', 'F♯0', 'G0', 'G♯0', 'A0', 'A♯0', 'B0'] |
| |
| Use a key signature to resolve enharmonic equivalences |
| |
| >>> librosa.midi_to_note(range(12, 24), key='F:min') |
| ['C0', 'D♭0', 'D0', 'E♭0', 'E0', 'F0', 'G♭0', 'G0', 'A♭0', 'A0', 'B♭0', 'B0'] |
| |
| Parameters |
| ---------- |
| midi : int or iterable of int |
| Midi numbers to convert. |
| |
| octave : bool |
| If True, include the octave number |
| |
| cents : bool |
| If true, cent markers will be appended for fractional notes. |
| Eg, ``midi_to_note(69.3, cents=True) == 'A4+03'`` |
| |
| key : str |
| A key signature to use when resolving enharmonic equivalences. |
| |
| unicode : bool |
| If ``True`` (default), accidentals will use Unicode notation: ♭ or ♯ |
| |
| If ``False``, accidentals will use ASCII-compatible notation: b or # |
| |
| Returns |
| ------- |
| notes : str or iterable of str |
| Strings describing each midi note. |
| |
| Raises |
| ------ |
| ParameterError |
| if ``cents`` is True and ``octave`` is False |
| |
| See Also |
| -------- |
| midi_to_hz |
| note_to_midi |
| hz_to_note |
| key_to_notes |
| """ |
|
|
| if cents and not octave: |
| raise ParameterError("Cannot encode cents without octave information.") |
|
|
| if not np.isscalar(midi): |
| return [ |
| midi_to_note(x, octave=octave, cents=cents, key=key, unicode=unicode) |
| for x in midi |
| ] |
|
|
| note_map = notation.key_to_notes(key=key, unicode=unicode) |
|
|
| note_num = int(np.round(midi)) |
| note_cents = int(100 * np.around(midi - note_num, 2)) |
|
|
| note = note_map[note_num % 12] |
|
|
| if octave: |
| note = "{:s}{:0d}".format(note, int(note_num / 12) - 1) |
| if cents: |
| note = "{:s}{:+02d}".format(note, note_cents) |
|
|
| return note |
|
|
|
|
| def midi_to_hz(notes): |
| """Get the frequency (Hz) of MIDI note(s) |
| |
| Examples |
| -------- |
| >>> librosa.midi_to_hz(36) |
| 65.406 |
| |
| >>> librosa.midi_to_hz(np.arange(36, 48)) |
| array([ 65.406, 69.296, 73.416, 77.782, 82.407, |
| 87.307, 92.499, 97.999, 103.826, 110. , |
| 116.541, 123.471]) |
| |
| Parameters |
| ---------- |
| notes : int or np.ndarray [shape=(n,), dtype=int] |
| midi number(s) of the note(s) |
| |
| Returns |
| ------- |
| frequency : number or np.ndarray [shape=(n,), dtype=float] |
| frequency (frequencies) of ``notes`` in Hz |
| |
| See Also |
| -------- |
| hz_to_midi |
| note_to_hz |
| """ |
|
|
| return 440.0 * (2.0 ** ((np.asanyarray(notes) - 69.0) / 12.0)) |
|
|
|
|
| def hz_to_midi(frequencies): |
| """Get MIDI note number(s) for given frequencies |
| |
| Examples |
| -------- |
| >>> librosa.hz_to_midi(60) |
| 34.506 |
| >>> librosa.hz_to_midi([110, 220, 440]) |
| array([ 45., 57., 69.]) |
| |
| Parameters |
| ---------- |
| frequencies : float or np.ndarray [shape=(n,), dtype=float] |
| frequencies to convert |
| |
| Returns |
| ------- |
| note_nums : number or np.ndarray [shape=(n,), dtype=float] |
| MIDI notes to ``frequencies`` |
| |
| See Also |
| -------- |
| midi_to_hz |
| note_to_midi |
| hz_to_note |
| """ |
|
|
| return 12 * (np.log2(np.asanyarray(frequencies)) - np.log2(440.0)) + 69 |
|
|
|
|
| def hz_to_note(frequencies, **kwargs): |
| """Convert one or more frequencies (in Hz) to the nearest note names. |
| |
| Parameters |
| ---------- |
| frequencies : float or iterable of float |
| Input frequencies, specified in Hz |
| **kwargs : additional keyword arguments |
| Arguments passed through to `midi_to_note` |
| |
| Returns |
| ------- |
| notes : list of str |
| ``notes[i]`` is the closest note name to ``frequency[i]`` |
| (or ``frequency`` if the input is scalar) |
| |
| See Also |
| -------- |
| hz_to_midi |
| midi_to_note |
| note_to_hz |
| |
| Examples |
| -------- |
| Get a single note name for a frequency |
| |
| >>> librosa.hz_to_note(440.0) |
| ['A5'] |
| |
| Get multiple notes with cent deviation |
| |
| >>> librosa.hz_to_note([32, 64], cents=True) |
| ['C1-38', 'C2-38'] |
| |
| Get multiple notes, but suppress octave labels |
| |
| >>> librosa.hz_to_note(440.0 * (2.0 ** np.linspace(0, 1, 12)), |
| ... octave=False) |
| ['A', 'A#', 'B', 'C', 'C#', 'D', 'E', 'F', 'F#', 'G', 'G#', 'A'] |
| |
| """ |
| return midi_to_note(hz_to_midi(frequencies), **kwargs) |
|
|
|
|
| @deprecate_positional_args |
| def hz_to_mel(frequencies, *, htk=False): |
| """Convert Hz to Mels |
| |
| Examples |
| -------- |
| >>> librosa.hz_to_mel(60) |
| 0.9 |
| >>> librosa.hz_to_mel([110, 220, 440]) |
| array([ 1.65, 3.3 , 6.6 ]) |
| |
| Parameters |
| ---------- |
| frequencies : number or np.ndarray [shape=(n,)] , float |
| scalar or array of frequencies |
| htk : bool |
| use HTK formula instead of Slaney |
| |
| Returns |
| ------- |
| mels : number or np.ndarray [shape=(n,)] |
| input frequencies in Mels |
| |
| See Also |
| -------- |
| mel_to_hz |
| """ |
|
|
| frequencies = np.asanyarray(frequencies) |
|
|
| if htk: |
| return 2595.0 * np.log10(1.0 + frequencies / 700.0) |
|
|
| |
| f_min = 0.0 |
| f_sp = 200.0 / 3 |
|
|
| mels = (frequencies - f_min) / f_sp |
|
|
| |
|
|
| min_log_hz = 1000.0 |
| min_log_mel = (min_log_hz - f_min) / f_sp |
| logstep = np.log(6.4) / 27.0 |
|
|
| if frequencies.ndim: |
| |
| log_t = frequencies >= min_log_hz |
| mels[log_t] = min_log_mel + np.log(frequencies[log_t] / min_log_hz) / logstep |
| elif frequencies >= min_log_hz: |
| |
| mels = min_log_mel + np.log(frequencies / min_log_hz) / logstep |
|
|
| return mels |
|
|
|
|
| @deprecate_positional_args |
| def mel_to_hz(mels, *, htk=False): |
| """Convert mel bin numbers to frequencies |
| |
| Examples |
| -------- |
| >>> librosa.mel_to_hz(3) |
| 200. |
| |
| >>> librosa.mel_to_hz([1,2,3,4,5]) |
| array([ 66.667, 133.333, 200. , 266.667, 333.333]) |
| |
| Parameters |
| ---------- |
| mels : np.ndarray [shape=(n,)], float |
| mel bins to convert |
| htk : bool |
| use HTK formula instead of Slaney |
| |
| Returns |
| ------- |
| frequencies : np.ndarray [shape=(n,)] |
| input mels in Hz |
| |
| See Also |
| -------- |
| hz_to_mel |
| """ |
|
|
| mels = np.asanyarray(mels) |
|
|
| if htk: |
| return 700.0 * (10.0 ** (mels / 2595.0) - 1.0) |
|
|
| |
| f_min = 0.0 |
| f_sp = 200.0 / 3 |
| freqs = f_min + f_sp * mels |
|
|
| |
| min_log_hz = 1000.0 |
| min_log_mel = (min_log_hz - f_min) / f_sp |
| logstep = np.log(6.4) / 27.0 |
|
|
| if mels.ndim: |
| |
| log_t = mels >= min_log_mel |
| freqs[log_t] = min_log_hz * np.exp(logstep * (mels[log_t] - min_log_mel)) |
| elif mels >= min_log_mel: |
| |
| freqs = min_log_hz * np.exp(logstep * (mels - min_log_mel)) |
|
|
| return freqs |
|
|
|
|
| @deprecate_positional_args |
| def hz_to_octs(frequencies, *, tuning=0.0, bins_per_octave=12): |
| """Convert frequencies (Hz) to (fractional) octave numbers. |
| |
| Examples |
| -------- |
| >>> librosa.hz_to_octs(440.0) |
| 4. |
| >>> librosa.hz_to_octs([32, 64, 128, 256]) |
| array([ 0.219, 1.219, 2.219, 3.219]) |
| |
| Parameters |
| ---------- |
| frequencies : number >0 or np.ndarray [shape=(n,)] or float |
| scalar or vector of frequencies |
| tuning : float |
| Tuning deviation from A440 in (fractional) bins per octave. |
| bins_per_octave : int > 0 |
| Number of bins per octave. |
| |
| Returns |
| ------- |
| octaves : number or np.ndarray [shape=(n,)] |
| octave number for each frequency |
| |
| See Also |
| -------- |
| octs_to_hz |
| """ |
|
|
| A440 = 440.0 * 2.0 ** (tuning / bins_per_octave) |
|
|
| return np.log2(np.asanyarray(frequencies) / (float(A440) / 16)) |
|
|
|
|
| @deprecate_positional_args |
| def octs_to_hz(octs, *, tuning=0.0, bins_per_octave=12): |
| """Convert octaves numbers to frequencies. |
| |
| Octaves are counted relative to A. |
| |
| Examples |
| -------- |
| >>> librosa.octs_to_hz(1) |
| 55. |
| >>> librosa.octs_to_hz([-2, -1, 0, 1, 2]) |
| array([ 6.875, 13.75 , 27.5 , 55. , 110. ]) |
| |
| Parameters |
| ---------- |
| octs : np.ndarray [shape=(n,)] or float |
| octave number for each frequency |
| tuning : float |
| Tuning deviation from A440 in (fractional) bins per octave. |
| bins_per_octave : int > 0 |
| Number of bins per octave. |
| |
| Returns |
| ------- |
| frequencies : number or np.ndarray [shape=(n,)] |
| scalar or vector of frequencies |
| |
| See Also |
| -------- |
| hz_to_octs |
| """ |
| A440 = 440.0 * 2.0 ** (tuning / bins_per_octave) |
|
|
| return (float(A440) / 16) * (2.0 ** np.asanyarray(octs)) |
|
|
|
|
| @deprecate_positional_args |
| def A4_to_tuning(A4, *, bins_per_octave=12): |
| """Convert a reference pitch frequency (e.g., ``A4=435``) to a tuning |
| estimation, in fractions of a bin per octave. |
| |
| This is useful for determining the tuning deviation relative to |
| A440 of a given frequency, assuming equal temperament. By default, |
| 12 bins per octave are used. |
| |
| This method is the inverse of `tuning_to_A4`. |
| |
| Examples |
| -------- |
| The base case of this method in which A440 yields 0 tuning offset |
| from itself. |
| |
| >>> librosa.A4_to_tuning(440.0) |
| 0. |
| |
| Convert a non-A440 frequency to a tuning offset relative |
| to A440 using the default of 12 bins per octave. |
| |
| >>> librosa.A4_to_tuning(432.0) |
| -0.318 |
| |
| Convert two reference pitch frequencies to corresponding |
| tuning estimations at once, but using 24 bins per octave. |
| |
| >>> librosa.A4_to_tuning([440.0, 444.0], bins_per_octave=24) |
| array([ 0., 0.313 ]) |
| |
| Parameters |
| ---------- |
| A4 : float or np.ndarray [shape=(n,), dtype=float] |
| Reference frequency(s) corresponding to A4. |
| bins_per_octave : int > 0 |
| Number of bins per octave. |
| |
| Returns |
| ------- |
| tuning : float or np.ndarray [shape=(n,), dtype=float] |
| Tuning deviation from A440 in (fractional) bins per octave. |
| |
| See Also |
| -------- |
| tuning_to_A4 |
| """ |
| return bins_per_octave * (np.log2(np.asanyarray(A4)) - np.log2(440.0)) |
|
|
|
|
| @deprecate_positional_args |
| def tuning_to_A4(tuning, *, bins_per_octave=12): |
| """Convert a tuning deviation (from 0) in fractions of a bin per |
| octave (e.g., ``tuning=-0.1``) to a reference pitch frequency |
| relative to A440. |
| |
| This is useful if you are working in a non-A440 tuning system |
| to determine the reference pitch frequency given a tuning |
| offset and assuming equal temperament. By default, 12 bins per |
| octave are used. |
| |
| This method is the inverse of `A4_to_tuning`. |
| |
| Examples |
| -------- |
| The base case of this method in which a tuning deviation of 0 |
| gets us to our A440 reference pitch. |
| |
| >>> librosa.tuning_to_A4(0.0) |
| 440. |
| |
| Convert a nonzero tuning offset to its reference pitch frequency. |
| |
| >>> librosa.tuning_to_A4(-0.318) |
| 431.992 |
| |
| Convert 3 tuning deviations at once to respective reference |
| pitch frequencies, using 36 bins per octave. |
| |
| >>> librosa.tuning_to_A4([0.1, 0.2, -0.1], bins_per_octave=36) |
| array([ 440.848, 441.698 439.154]) |
| |
| Parameters |
| ---------- |
| tuning : float or np.ndarray [shape=(n,), dtype=float] |
| Tuning deviation from A440 in fractional bins per octave. |
| bins_per_octave : int > 0 |
| Number of bins per octave. |
| |
| Returns |
| ------- |
| A4 : float or np.ndarray [shape=(n,), dtype=float] |
| Reference frequency corresponding to A4. |
| |
| See Also |
| -------- |
| A4_to_tuning |
| """ |
| return 440.0 * 2.0 ** (np.asanyarray(tuning) / bins_per_octave) |
|
|
|
|
| @deprecate_positional_args |
| def fft_frequencies(*, sr=22050, n_fft=2048): |
| """Alternative implementation of `np.fft.fftfreq` |
| |
| Parameters |
| ---------- |
| sr : number > 0 [scalar] |
| Audio sampling rate |
| n_fft : int > 0 [scalar] |
| FFT window size |
| |
| Returns |
| ------- |
| freqs : np.ndarray [shape=(1 + n_fft/2,)] |
| Frequencies ``(0, sr/n_fft, 2*sr/n_fft, ..., sr/2)`` |
| |
| Examples |
| -------- |
| >>> librosa.fft_frequencies(sr=22050, n_fft=16) |
| array([ 0. , 1378.125, 2756.25 , 4134.375, |
| 5512.5 , 6890.625, 8268.75 , 9646.875, 11025. ]) |
| |
| """ |
|
|
| return np.fft.rfftfreq(n=n_fft, d=1.0 / sr) |
|
|
|
|
| @deprecate_positional_args |
| def cqt_frequencies(n_bins, *, fmin, bins_per_octave=12, tuning=0.0): |
| """Compute the center frequencies of Constant-Q bins. |
| |
| Examples |
| -------- |
| >>> # Get the CQT frequencies for 24 notes, starting at C2 |
| >>> librosa.cqt_frequencies(24, fmin=librosa.note_to_hz('C2')) |
| array([ 65.406, 69.296, 73.416, 77.782, 82.407, 87.307, |
| 92.499, 97.999, 103.826, 110. , 116.541, 123.471, |
| 130.813, 138.591, 146.832, 155.563, 164.814, 174.614, |
| 184.997, 195.998, 207.652, 220. , 233.082, 246.942]) |
| |
| Parameters |
| ---------- |
| n_bins : int > 0 [scalar] |
| Number of constant-Q bins |
| fmin : float > 0 [scalar] |
| Minimum frequency |
| bins_per_octave : int > 0 [scalar] |
| Number of bins per octave |
| tuning : float |
| Deviation from A440 tuning in fractional bins |
| |
| Returns |
| ------- |
| frequencies : np.ndarray [shape=(n_bins,)] |
| Center frequency for each CQT bin |
| """ |
|
|
| correction = 2.0 ** (float(tuning) / bins_per_octave) |
| frequencies = 2.0 ** (np.arange(0, n_bins, dtype=float) / bins_per_octave) |
|
|
| return correction * fmin * frequencies |
|
|
|
|
| @deprecate_positional_args |
| def mel_frequencies(n_mels=128, *, fmin=0.0, fmax=11025.0, htk=False): |
| """Compute an array of acoustic frequencies tuned to the mel scale. |
| |
| The mel scale is a quasi-logarithmic function of acoustic frequency |
| designed such that perceptually similar pitch intervals (e.g. octaves) |
| appear equal in width over the full hearing range. |
| |
| Because the definition of the mel scale is conditioned by a finite number |
| of subjective psychoaoustical experiments, several implementations coexist |
| in the audio signal processing literature [#]_. By default, librosa replicates |
| the behavior of the well-established MATLAB Auditory Toolbox of Slaney [#]_. |
| According to this default implementation, the conversion from Hertz to mel is |
| linear below 1 kHz and logarithmic above 1 kHz. Another available implementation |
| replicates the Hidden Markov Toolkit [#]_ (HTK) according to the following formula:: |
| |
| mel = 2595.0 * np.log10(1.0 + f / 700.0). |
| |
| The choice of implementation is determined by the ``htk`` keyword argument: setting |
| ``htk=False`` leads to the Auditory toolbox implementation, whereas setting it ``htk=True`` |
| leads to the HTK implementation. |
| |
| .. [#] Umesh, S., Cohen, L., & Nelson, D. Fitting the mel scale. |
| In Proc. International Conference on Acoustics, Speech, and Signal Processing |
| (ICASSP), vol. 1, pp. 217-220, 1998. |
| |
| .. [#] Slaney, M. Auditory Toolbox: A MATLAB Toolbox for Auditory |
| Modeling Work. Technical Report, version 2, Interval Research Corporation, 1998. |
| |
| .. [#] Young, S., Evermann, G., Gales, M., Hain, T., Kershaw, D., Liu, X., |
| Moore, G., Odell, J., Ollason, D., Povey, D., Valtchev, V., & Woodland, P. |
| The HTK book, version 3.4. Cambridge University, March 2009. |
| |
| See Also |
| -------- |
| hz_to_mel |
| mel_to_hz |
| librosa.feature.melspectrogram |
| librosa.feature.mfcc |
| |
| Parameters |
| ---------- |
| n_mels : int > 0 [scalar] |
| Number of mel bins. |
| fmin : float >= 0 [scalar] |
| Minimum frequency (Hz). |
| fmax : float >= 0 [scalar] |
| Maximum frequency (Hz). |
| htk : bool |
| If True, use HTK formula to convert Hz to mel. |
| Otherwise (False), use Slaney's Auditory Toolbox. |
| |
| Returns |
| ------- |
| bin_frequencies : ndarray [shape=(n_mels,)] |
| Vector of ``n_mels`` frequencies in Hz which are uniformly spaced on the Mel |
| axis. |
| |
| Examples |
| -------- |
| >>> librosa.mel_frequencies(n_mels=40) |
| array([ 0. , 85.317, 170.635, 255.952, |
| 341.269, 426.586, 511.904, 597.221, |
| 682.538, 767.855, 853.173, 938.49 , |
| 1024.856, 1119.114, 1222.042, 1334.436, |
| 1457.167, 1591.187, 1737.532, 1897.337, |
| 2071.84 , 2262.393, 2470.47 , 2697.686, |
| 2945.799, 3216.731, 3512.582, 3835.643, |
| 4188.417, 4573.636, 4994.285, 5453.621, |
| 5955.205, 6502.92 , 7101.009, 7754.107, |
| 8467.272, 9246.028, 10096.408, 11025. ]) |
| |
| """ |
|
|
| |
| min_mel = hz_to_mel(fmin, htk=htk) |
| max_mel = hz_to_mel(fmax, htk=htk) |
|
|
| mels = np.linspace(min_mel, max_mel, n_mels) |
|
|
| return mel_to_hz(mels, htk=htk) |
|
|
|
|
| @deprecate_positional_args |
| def tempo_frequencies(n_bins, *, hop_length=512, sr=22050): |
| """Compute the frequencies (in beats per minute) corresponding |
| to an onset auto-correlation or tempogram matrix. |
| |
| Parameters |
| ---------- |
| n_bins : int > 0 |
| The number of lag bins |
| hop_length : int > 0 |
| The number of samples between each bin |
| sr : number > 0 |
| The audio sampling rate |
| |
| Returns |
| ------- |
| bin_frequencies : ndarray [shape=(n_bins,)] |
| vector of bin frequencies measured in BPM. |
| |
| .. note:: ``bin_frequencies[0] = +np.inf`` corresponds to 0-lag |
| |
| Examples |
| -------- |
| Get the tempo frequencies corresponding to a 384-bin (8-second) tempogram |
| |
| >>> librosa.tempo_frequencies(384) |
| array([ inf, 2583.984, 1291.992, ..., 6.782, |
| 6.764, 6.747]) |
| """ |
|
|
| bin_frequencies = np.zeros(int(n_bins), dtype=np.float64) |
|
|
| bin_frequencies[0] = np.inf |
| bin_frequencies[1:] = 60.0 * sr / (hop_length * np.arange(1.0, n_bins)) |
|
|
| return bin_frequencies |
|
|
|
|
| @deprecate_positional_args |
| def fourier_tempo_frequencies(*, sr=22050, win_length=384, hop_length=512): |
| """Compute the frequencies (in beats per minute) corresponding |
| to a Fourier tempogram matrix. |
| |
| Parameters |
| ---------- |
| sr : number > 0 |
| The audio sampling rate |
| win_length : int > 0 |
| The number of frames per analysis window |
| hop_length : int > 0 |
| The number of samples between each bin |
| |
| Returns |
| ------- |
| bin_frequencies : ndarray [shape=(win_length // 2 + 1 ,)] |
| vector of bin frequencies measured in BPM. |
| |
| Examples |
| -------- |
| Get the tempo frequencies corresponding to a 384-bin (8-second) tempogram |
| |
| >>> librosa.fourier_tempo_frequencies(win_length=384) |
| array([ 0. , 0.117, 0.234, ..., 22.266, 22.383, 22.5 ]) |
| |
| """ |
|
|
| |
| |
| return fft_frequencies(sr=sr * 60 / float(hop_length), n_fft=win_length) |
|
|
|
|
| |
| @deprecate_positional_args |
| def A_weighting(frequencies, *, min_db=-80.0): |
| """Compute the A-weighting of a set of frequencies. |
| |
| Parameters |
| ---------- |
| frequencies : scalar or np.ndarray [shape=(n,)] |
| One or more frequencies (in Hz) |
| min_db : float [scalar] or None |
| Clip weights below this threshold. |
| If `None`, no clipping is performed. |
| |
| Returns |
| ------- |
| A_weighting : scalar or np.ndarray [shape=(n,)] |
| ``A_weighting[i]`` is the A-weighting of ``frequencies[i]`` |
| |
| See Also |
| -------- |
| perceptual_weighting |
| frequency_weighting |
| multi_frequency_weighting |
| B_weighting |
| C_weighting |
| D_weighting |
| |
| Examples |
| -------- |
| Get the A-weighting for CQT frequencies |
| |
| >>> import matplotlib.pyplot as plt |
| >>> freqs = librosa.cqt_frequencies(n_bins=108, fmin=librosa.note_to_hz('C1')) |
| >>> weights = librosa.A_weighting(freqs) |
| >>> fig, ax = plt.subplots() |
| >>> ax.plot(freqs, weights) |
| >>> ax.set(xlabel='Frequency (Hz)', |
| ... ylabel='Weighting (log10)', |
| ... title='A-Weighting of CQT frequencies') |
| """ |
| f_sq = np.asanyarray(frequencies) ** 2.0 |
|
|
| const = np.array([12194.217, 20.598997, 107.65265, 737.86223]) ** 2.0 |
| weights = 2.0 + 20.0 * ( |
| np.log10(const[0]) |
| + 2 * np.log10(f_sq) |
| - np.log10(f_sq + const[0]) |
| - np.log10(f_sq + const[1]) |
| - 0.5 * np.log10(f_sq + const[2]) |
| - 0.5 * np.log10(f_sq + const[3]) |
| ) |
|
|
| return weights if min_db is None else np.maximum(min_db, weights) |
|
|
|
|
| @deprecate_positional_args |
| def B_weighting(frequencies, *, min_db=-80.0): |
| """Compute the B-weighting of a set of frequencies. |
| |
| Parameters |
| ---------- |
| frequencies : scalar or np.ndarray [shape=(n,)] |
| One or more frequencies (in Hz) |
| min_db : float [scalar] or None |
| Clip weights below this threshold. |
| If `None`, no clipping is performed. |
| |
| Returns |
| ------- |
| B_weighting : scalar or np.ndarray [shape=(n,)] |
| ``B_weighting[i]`` is the B-weighting of ``frequencies[i]`` |
| |
| See Also |
| -------- |
| perceptual_weighting |
| frequency_weighting |
| multi_frequency_weighting |
| A_weighting |
| C_weighting |
| D_weighting |
| |
| Examples |
| -------- |
| Get the B-weighting for CQT frequencies |
| |
| >>> import matplotlib.pyplot as plt |
| >>> freqs = librosa.cqt_frequencies(n_bins=108, fmin=librosa.note_to_hz('C1')) |
| >>> weights = librosa.B_weighting(freqs) |
| >>> fig, ax = plt.subplots() |
| >>> ax.plot(freqs, weights) |
| >>> ax.set(xlabel='Frequency (Hz)', |
| ... ylabel='Weighting (log10)', |
| ... title='B-Weighting of CQT frequencies') |
| """ |
| f_sq = np.asanyarray(frequencies) ** 2.0 |
|
|
| const = np.array([12194.217, 20.598997, 158.48932]) ** 2.0 |
| weights = 0.17 + 20.0 * ( |
| np.log10(const[0]) |
| + 1.5 * np.log10(f_sq) |
| - np.log10(f_sq + const[0]) |
| - np.log10(f_sq + const[1]) |
| - 0.5 * np.log10(f_sq + const[2]) |
| ) |
|
|
| return weights if min_db is None else np.maximum(min_db, weights) |
|
|
|
|
| @deprecate_positional_args |
| def C_weighting(frequencies, *, min_db=-80.0): |
| """Compute the C-weighting of a set of frequencies. |
| |
| Parameters |
| ---------- |
| frequencies : scalar or np.ndarray [shape=(n,)] |
| One or more frequencies (in Hz) |
| min_db : float [scalar] or None |
| Clip weights below this threshold. |
| If `None`, no clipping is performed. |
| |
| Returns |
| ------- |
| C_weighting : scalar or np.ndarray [shape=(n,)] |
| ``C_weighting[i]`` is the C-weighting of ``frequencies[i]`` |
| |
| See Also |
| -------- |
| perceptual_weighting |
| frequency_weighting |
| multi_frequency_weighting |
| A_weighting |
| B_weighting |
| D_weighting |
| |
| Examples |
| -------- |
| Get the C-weighting for CQT frequencies |
| |
| >>> import matplotlib.pyplot as plt |
| >>> freqs = librosa.cqt_frequencies(n_bins=108, fmin=librosa.note_to_hz('C1')) |
| >>> weights = librosa.C_weighting(freqs) |
| >>> fig, ax = plt.subplots() |
| >>> ax.plot(freqs, weights) |
| >>> ax.set(xlabel='Frequency (Hz)', ylabel='Weighting (log10)', |
| ... title='C-Weighting of CQT frequencies') |
| """ |
| f_sq = np.asanyarray(frequencies) ** 2.0 |
|
|
| const = np.array([12194.217, 20.598997]) ** 2.0 |
| weights = 0.062 + 20.0 * ( |
| np.log10(const[0]) |
| + np.log10(f_sq) |
| - np.log10(f_sq + const[0]) |
| - np.log10(f_sq + const[1]) |
| ) |
|
|
| return weights if min_db is None else np.maximum(min_db, weights) |
|
|
|
|
| @deprecate_positional_args |
| def D_weighting(frequencies, *, min_db=-80.0): |
| """Compute the D-weighting of a set of frequencies. |
| |
| Parameters |
| ---------- |
| frequencies : scalar or np.ndarray [shape=(n,)] |
| One or more frequencies (in Hz) |
| min_db : float [scalar] or None |
| Clip weights below this threshold. |
| If `None`, no clipping is performed. |
| |
| Returns |
| ------- |
| D_weighting : scalar or np.ndarray [shape=(n,)] |
| ``D_weighting[i]`` is the D-weighting of ``frequencies[i]`` |
| |
| See Also |
| -------- |
| perceptual_weighting |
| frequency_weighting |
| multi_frequency_weighting |
| A_weighting |
| B_weighting |
| C_weighting |
| |
| Examples |
| -------- |
| Get the D-weighting for CQT frequencies |
| |
| >>> import matplotlib.pyplot as plt |
| >>> freqs = librosa.cqt_frequencies(n_bins=108, fmin=librosa.note_to_hz('C1')) |
| >>> weights = librosa.D_weighting(freqs) |
| >>> fig, ax = plt.subplots() |
| >>> ax.plot(freqs, weights) |
| >>> ax.set(xlabel='Frequency (Hz)', ylabel='Weighting (log10)', |
| ... title='D-Weighting of CQT frequencies') |
| """ |
| f_sq = np.asanyarray(frequencies) ** 2.0 |
|
|
| const = np.array([8.3046305e-3, 1018.7, 1039.6, 3136.5, 3424, 282.7, 1160]) ** 2.0 |
| weights = 20.0 * ( |
| 0.5 * np.log10(f_sq) |
| - np.log10(const[0]) |
| + 0.5 |
| * ( |
| +np.log10((const[1] - f_sq) ** 2 + const[2] * f_sq) |
| - np.log10((const[3] - f_sq) ** 2 + const[4] * f_sq) |
| - np.log10(const[5] + f_sq) |
| - np.log10(const[6] + f_sq) |
| ) |
| ) |
|
|
| return weights if min_db is None else np.maximum(min_db, weights) |
|
|
|
|
| @deprecate_positional_args |
| def Z_weighting(frequencies, *, min_db=None): |
| weights = np.zeros(len(frequencies)) |
| return weights if min_db is None else np.maximum(min_db, weights) |
|
|
|
|
| WEIGHTING_FUNCTIONS = { |
| "A": A_weighting, |
| "B": B_weighting, |
| "C": C_weighting, |
| "D": D_weighting, |
| "Z": Z_weighting, |
| None: Z_weighting, |
| } |
|
|
|
|
| @deprecate_positional_args |
| def frequency_weighting(frequencies, *, kind="A", **kwargs): |
| """Compute the weighting of a set of frequencies. |
| |
| Parameters |
| ---------- |
| frequencies : scalar or np.ndarray [shape=(n,)] |
| One or more frequencies (in Hz) |
| kind : str in |
| The weighting kind. e.g. `'A'`, `'B'`, `'C'`, `'D'`, `'Z'` |
| **kwargs |
| Additional keyword arguments to A_weighting, B_weighting, etc. |
| |
| Returns |
| ------- |
| weighting : scalar or np.ndarray [shape=(n,)] |
| ``weighting[i]`` is the weighting of ``frequencies[i]`` |
| |
| See Also |
| -------- |
| perceptual_weighting |
| multi_frequency_weighting |
| A_weighting |
| B_weighting |
| C_weighting |
| D_weighting |
| |
| Examples |
| -------- |
| Get the A-weighting for CQT frequencies |
| |
| >>> import matplotlib.pyplot as plt |
| >>> freqs = librosa.cqt_frequencies(n_bins=108, fmin=librosa.note_to_hz('C1')) |
| >>> weights = librosa.frequency_weighting(freqs, kind='A') |
| >>> fig, ax = plt.subplots() |
| >>> ax.plot(freqs, weights) |
| >>> ax.set(xlabel='Frequency (Hz)', ylabel='Weighting (log10)', |
| ... title='A-Weighting of CQT frequencies') |
| """ |
| if isinstance(kind, str): |
| kind = kind.upper() |
| return WEIGHTING_FUNCTIONS[kind](frequencies, **kwargs) |
|
|
|
|
| @deprecate_positional_args |
| def multi_frequency_weighting(frequencies, *, kinds="ZAC", **kwargs): |
| """Compute multiple weightings of a set of frequencies. |
| |
| Parameters |
| ---------- |
| frequencies : scalar or np.ndarray [shape=(n,)] |
| One or more frequencies (in Hz) |
| kinds : list or tuple or str |
| An iterable of weighting kinds. e.g. `('Z', 'B')`, `'ZAD'`, `'C'` |
| **kwargs : keywords to pass to the weighting function. |
| |
| Returns |
| ------- |
| weighting : scalar or np.ndarray [shape=(len(kinds), n)] |
| ``weighting[i, j]`` is the weighting of ``frequencies[j]`` |
| using the curve determined by ``kinds[i]``. |
| |
| See Also |
| -------- |
| perceptual_weighting |
| frequency_weighting |
| A_weighting |
| B_weighting |
| C_weighting |
| D_weighting |
| |
| Examples |
| -------- |
| Get the A, B, C, D, and Z weightings for CQT frequencies |
| |
| >>> import matplotlib.pyplot as plt |
| >>> freqs = librosa.cqt_frequencies(n_bins=108, fmin=librosa.note_to_hz('C1')) |
| >>> weightings = 'ABCDZ' |
| >>> weights = librosa.multi_frequency_weighting(freqs, kinds=weightings) |
| >>> fig, ax = plt.subplots() |
| >>> for label, w in zip(weightings, weights): |
| ... ax.plot(freqs, w, label=label) |
| >>> ax.set(xlabel='Frequency (Hz)', ylabel='Weighting (log10)', |
| ... title='Weightings of CQT frequencies') |
| >>> ax.legend() |
| """ |
| return np.stack( |
| [frequency_weighting(frequencies, kind=k, **kwargs) for k in kinds], axis=0 |
| ) |
|
|
|
|
| @deprecate_positional_args |
| def times_like(X, *, sr=22050, hop_length=512, n_fft=None, axis=-1): |
| """Return an array of time values to match the time axis from a feature matrix. |
| |
| Parameters |
| ---------- |
| X : np.ndarray or scalar |
| - If ndarray, X is a feature matrix, e.g. STFT, chromagram, or mel spectrogram. |
| - If scalar, X represents the number of frames. |
| sr : number > 0 [scalar] |
| audio sampling rate |
| hop_length : int > 0 [scalar] |
| number of samples between successive frames |
| n_fft : None or int > 0 [scalar] |
| Optional: length of the FFT window. |
| If given, time conversion will include an offset of ``n_fft // 2`` |
| to counteract windowing effects when using a non-centered STFT. |
| axis : int [scalar] |
| The axis representing the time axis of X. |
| By default, the last axis (-1) is taken. |
| |
| Returns |
| ------- |
| times : np.ndarray [shape=(n,)] |
| ndarray of times (in seconds) corresponding to each frame of X. |
| |
| See Also |
| -------- |
| samples_like : |
| Return an array of sample indices to match the time axis from a feature matrix. |
| |
| Examples |
| -------- |
| Provide a feature matrix input: |
| |
| >>> y, sr = librosa.load(librosa.ex('trumpet')) |
| >>> D = librosa.stft(y) |
| >>> times = librosa.times_like(D) |
| >>> times |
| array([0. , 0.023, ..., 5.294, 5.317]) |
| |
| Provide a scalar input: |
| |
| >>> n_frames = 2647 |
| >>> times = librosa.times_like(n_frames) |
| >>> times |
| array([ 0.00000000e+00, 2.32199546e-02, 4.64399093e-02, ..., |
| 6.13935601e+01, 6.14167800e+01, 6.14400000e+01]) |
| """ |
| samples = samples_like(X, hop_length=hop_length, n_fft=n_fft, axis=axis) |
| return samples_to_time(samples, sr=sr) |
|
|
|
|
| @deprecate_positional_args |
| def samples_like(X, *, hop_length=512, n_fft=None, axis=-1): |
| """Return an array of sample indices to match the time axis from a feature matrix. |
| |
| Parameters |
| ---------- |
| X : np.ndarray or scalar |
| - If ndarray, X is a feature matrix, e.g. STFT, chromagram, or mel spectrogram. |
| - If scalar, X represents the number of frames. |
| hop_length : int > 0 [scalar] |
| number of samples between successive frames |
| n_fft : None or int > 0 [scalar] |
| Optional: length of the FFT window. |
| If given, time conversion will include an offset of ``n_fft // 2`` |
| to counteract windowing effects when using a non-centered STFT. |
| axis : int [scalar] |
| The axis representing the time axis of ``X``. |
| By default, the last axis (-1) is taken. |
| |
| Returns |
| ------- |
| samples : np.ndarray [shape=(n,)] |
| ndarray of sample indices corresponding to each frame of ``X``. |
| |
| See Also |
| -------- |
| times_like : |
| Return an array of time values to match the time axis from a feature matrix. |
| |
| Examples |
| -------- |
| Provide a feature matrix input: |
| |
| >>> y, sr = librosa.load(librosa.ex('trumpet')) |
| >>> X = librosa.stft(y) |
| >>> samples = librosa.samples_like(X) |
| >>> samples |
| array([ 0, 512, ..., 116736, 117248]) |
| |
| Provide a scalar input: |
| |
| >>> n_frames = 2647 |
| >>> samples = librosa.samples_like(n_frames) |
| >>> samples |
| array([ 0, 512, 1024, ..., 1353728, 1354240, 1354752]) |
| """ |
| if np.isscalar(X): |
| frames = np.arange(X) |
| else: |
| frames = np.arange(X.shape[axis]) |
| return frames_to_samples(frames, hop_length=hop_length, n_fft=n_fft) |
|
|
|
|
| @deprecate_positional_args |
| def midi_to_svara_h(midi, *, Sa, abbr=True, octave=True, unicode=True): |
| """Convert MIDI numbers to Hindustani svara |
| |
| Parameters |
| ---------- |
| midi : numeric or np.ndarray |
| The MIDI number or numbers to convert |
| |
| Sa : number > 0 |
| MIDI number of the reference Sa. |
| |
| abbr : bool |
| If `True` (default) return abbreviated names ('S', 'r', 'R', 'g', 'G', ...) |
| |
| If `False`, return long-form names ('Sa', 're', 'Re', 'ga', 'Ga', ...) |
| |
| octave : bool |
| If `True`, decorate svara in neighboring octaves with over- or under-dots. |
| |
| If `False`, ignore octave height information. |
| |
| unicode : bool |
| If `True`, use unicode symbols to decorate octave information. |
| |
| If `False`, use low-order ASCII (' and ,) for octave decorations. |
| |
| This only takes effect if `octave=True`. |
| |
| Returns |
| ------- |
| svara : str or list of str |
| The svara corresponding to the given MIDI number(s) |
| |
| See Also |
| -------- |
| hz_to_svara_h |
| note_to_svara_h |
| midi_to_svara_c |
| midi_to_note |
| |
| Examples |
| -------- |
| The first three svara with Sa at midi number 60: |
| |
| >>> librosa.midi_svara_h([60, 61, 62], Sa=60) |
| ['S', 'r', 'R'] |
| |
| With Sa=67, midi 60-62 are in the octave below: |
| |
| >>> librosa.midi_to_svara_h([60, 61, 62], Sa=67) |
| ['ṃ', 'Ṃ', 'P̣'] |
| |
| Or without unicode decoration: |
| |
| >>> librosa.midi_to_svara_h([60, 61, 62], Sa=67, unicode=False) |
| ['m,', 'M,', 'P,'] |
| |
| Or going up an octave, with Sa=60, and using unabbreviated notes |
| |
| >>> librosa.midi_to_svara_h([72, 73, 74], Sa=60, abbr=False) |
| ['Ṡa', 'ṙe', 'Ṙe'] |
| """ |
|
|
| SVARA_MAP = [ |
| "Sa", |
| "re", |
| "Re", |
| "ga", |
| "Ga", |
| "ma", |
| "Ma", |
| "Pa", |
| "dha", |
| "Dha", |
| "ni", |
| "Ni", |
| ] |
|
|
| SVARA_MAP_SHORT = list(s[0] for s in SVARA_MAP) |
|
|
| if not np.isscalar(midi): |
| return [ |
| midi_to_svara_h(m, Sa=Sa, abbr=abbr, octave=octave, unicode=unicode) |
| for m in midi |
| ] |
|
|
| svara_num = int(np.round(midi - Sa)) |
|
|
| if abbr: |
| svara = SVARA_MAP_SHORT[svara_num % 12] |
| else: |
| svara = SVARA_MAP[svara_num % 12] |
|
|
| if octave: |
| if 24 > svara_num >= 12: |
| if unicode: |
| svara = svara[0] + "\u0307" + svara[1:] |
| else: |
| svara += "'" |
| elif -12 <= svara_num < 0: |
| if unicode: |
| svara = svara[0] + "\u0323" + svara[1:] |
| else: |
| svara += "," |
|
|
| return svara |
|
|
|
|
| @deprecate_positional_args |
| def hz_to_svara_h(frequencies, *, Sa, abbr=True, octave=True, unicode=True): |
| """Convert frequencies (in Hz) to Hindustani svara |
| |
| Note that this conversion assumes 12-tone equal temperament. |
| |
| Parameters |
| ---------- |
| frequencies : positive number or np.ndarray |
| The frequencies (in Hz) to convert |
| |
| Sa : positive number |
| Frequency (in Hz) of the reference Sa. |
| |
| abbr : bool |
| If `True` (default) return abbreviated names ('S', 'r', 'R', 'g', 'G', ...) |
| |
| If `False`, return long-form names ('Sa', 're', 'Re', 'ga', 'Ga', ...) |
| |
| octave : bool |
| If `True`, decorate svara in neighboring octaves with over- or under-dots. |
| |
| If `False`, ignore octave height information. |
| |
| unicode : bool |
| If `True`, use unicode symbols to decorate octave information. |
| |
| If `False`, use low-order ASCII (' and ,) for octave decorations. |
| |
| This only takes effect if `octave=True`. |
| |
| Returns |
| ------- |
| svara : str or list of str |
| The svara corresponding to the given frequency/frequencies |
| |
| See Also |
| -------- |
| midi_to_svara_h |
| note_to_svara_h |
| hz_to_svara_c |
| hz_to_note |
| |
| Examples |
| -------- |
| Convert Sa in three octaves: |
| |
| >>> librosa.hz_to_svara_h([261/2, 261, 261*2], Sa=261) |
| ['Ṣ', 'S', 'Ṡ'] |
| |
| Convert one octave worth of frequencies with full names: |
| |
| >>> freqs = librosa.cqt_frequencies(n_bins=12, fmin=261) |
| >>> librosa.hz_to_svara_h(freqs, Sa=freqs[0], abbr=False) |
| ['Sa', 're', 'Re', 'ga', 'Ga', 'ma', 'Ma', 'Pa', 'dha', 'Dha', 'ni', 'Ni'] |
| """ |
|
|
| midis = hz_to_midi(frequencies) |
| return midi_to_svara_h( |
| midis, Sa=hz_to_midi(Sa), abbr=abbr, octave=octave, unicode=unicode |
| ) |
|
|
|
|
| @deprecate_positional_args |
| def note_to_svara_h(notes, *, Sa, abbr=True, octave=True, unicode=True): |
| """Convert western notes to Hindustani svara |
| |
| Note that this conversion assumes 12-tone equal temperament. |
| |
| Parameters |
| ---------- |
| notes : str or list of str |
| Notes to convert (e.g., `'C#'` or `['C4', 'Db4', 'D4']` |
| |
| Sa : str |
| Note corresponding to Sa (e.g., `'C'` or `'C5'`). |
| |
| If no octave information is provided, it will default to octave 0 |
| (``C0`` ~= 16 Hz) |
| |
| abbr : bool |
| If `True` (default) return abbreviated names ('S', 'r', 'R', 'g', 'G', ...) |
| |
| If `False`, return long-form names ('Sa', 're', 'Re', 'ga', 'Ga', ...) |
| |
| octave : bool |
| If `True`, decorate svara in neighboring octaves with over- or under-dots. |
| |
| If `False`, ignore octave height information. |
| |
| unicode : bool |
| If `True`, use unicode symbols to decorate octave information. |
| |
| If `False`, use low-order ASCII (' and ,) for octave decorations. |
| |
| This only takes effect if `octave=True`. |
| |
| Returns |
| ------- |
| svara : str or list of str |
| The svara corresponding to the given notes |
| |
| See Also |
| -------- |
| midi_to_svara_h |
| hz_to_svara_h |
| note_to_svara_c |
| note_to_midi |
| note_to_hz |
| |
| Examples |
| -------- |
| >>> librosa.note_to_svara_h(['C4', 'G4', 'C5', 'G5'], Sa='C5') |
| ['Ṣ', 'P̣', 'S', 'P'] |
| """ |
|
|
| midis = note_to_midi(notes, round_midi=False) |
|
|
| return midi_to_svara_h( |
| midis, Sa=note_to_midi(Sa), abbr=abbr, octave=octave, unicode=unicode |
| ) |
|
|
|
|
| @deprecate_positional_args |
| def midi_to_svara_c(midi, *, Sa, mela, abbr=True, octave=True, unicode=True): |
| """Convert MIDI numbers to Carnatic svara within a given melakarta raga |
| |
| Parameters |
| ---------- |
| midi : numeric |
| The MIDI numbers to convert |
| |
| Sa : number > 0 |
| MIDI number of the reference Sa. |
| |
| Default: 60 (261.6 Hz, `C4`) |
| |
| mela : int or str |
| The name or index of the melakarta raga |
| |
| abbr : bool |
| If `True` (default) return abbreviated names ('S', 'R1', 'R2', 'G1', 'G2', ...) |
| |
| If `False`, return long-form names ('Sa', 'Ri1', 'Ri2', 'Ga1', 'Ga2', ...) |
| |
| octave : bool |
| If `True`, decorate svara in neighboring octaves with over- or under-dots. |
| |
| If `False`, ignore octave height information. |
| |
| unicode : bool |
| If `True`, use unicode symbols to decorate octave information and subscript |
| numbers. |
| |
| If `False`, use low-order ASCII (' and ,) for octave decorations. |
| |
| Returns |
| ------- |
| svara : str or list of str |
| The svara corresponding to the given MIDI number(s) |
| |
| See Also |
| -------- |
| hz_to_svara_c |
| note_to_svara_c |
| mela_to_degrees |
| mela_to_svara |
| list_mela |
| """ |
| if not np.isscalar(midi): |
| return [ |
| midi_to_svara_c( |
| m, Sa=Sa, mela=mela, abbr=abbr, octave=octave, unicode=unicode |
| ) |
| for m in midi |
| ] |
|
|
| svara_num = int(np.round(midi - Sa)) |
|
|
| svara_map = notation.mela_to_svara(mela, abbr=abbr, unicode=unicode) |
|
|
| svara = svara_map[svara_num % 12] |
|
|
| if octave: |
| if 24 > svara_num >= 12: |
| if unicode: |
| svara = svara[0] + "\u0307" + svara[1:] |
| else: |
| svara += "'" |
| elif -12 <= svara_num < 0: |
| if unicode: |
| svara = svara[0] + "\u0323" + svara[1:] |
| else: |
| svara += "," |
|
|
| return svara |
|
|
|
|
| @deprecate_positional_args |
| def hz_to_svara_c(frequencies, *, Sa, mela, abbr=True, octave=True, unicode=True): |
| """Convert frequencies (in Hz) to Carnatic svara |
| |
| Note that this conversion assumes 12-tone equal temperament. |
| |
| Parameters |
| ---------- |
| frequencies : positive number or np.ndarray |
| The frequencies (in Hz) to convert |
| |
| Sa : positive number |
| Frequency (in Hz) of the reference Sa. |
| |
| mela : int [1, 72] or string |
| The melakarta raga to use. |
| |
| abbr : bool |
| If `True` (default) return abbreviated names ('S', 'R1', 'R2', 'G1', 'G2', ...) |
| |
| If `False`, return long-form names ('Sa', 'Ri1', 'Ri2', 'Ga1', 'Ga2', ...) |
| |
| octave : bool |
| If `True`, decorate svara in neighboring octaves with over- or under-dots. |
| |
| If `False`, ignore octave height information. |
| |
| unicode : bool |
| If `True`, use unicode symbols to decorate octave information. |
| |
| If `False`, use low-order ASCII (' and ,) for octave decorations. |
| |
| This only takes effect if `octave=True`. |
| |
| Returns |
| ------- |
| svara : str or list of str |
| The svara corresponding to the given frequency/frequencies |
| |
| See Also |
| -------- |
| note_to_svara_c |
| midi_to_svara_c |
| hz_to_svara_h |
| hz_to_note |
| list_mela |
| |
| Examples |
| -------- |
| Convert Sa in three octaves: |
| |
| >>> librosa.hz_to_svara_c([261/2, 261, 261*2], Sa=261, mela='kanakangi') |
| ['Ṣ', 'S', 'Ṡ'] |
| |
| Convert one octave worth of frequencies using melakarta #36: |
| |
| >>> freqs = librosa.cqt_frequencies(n_bins=12, fmin=261) |
| >>> librosa.hz_to_svara_c(freqs, Sa=freqs[0], mela=36) |
| ['S', 'R₁', 'R₂', 'R₃', 'G₃', 'M₁', 'M₂', 'P', 'D₁', 'D₂', 'D₃', 'N₃'] |
| """ |
|
|
| midis = hz_to_midi(frequencies) |
| return midi_to_svara_c( |
| midis, Sa=hz_to_midi(Sa), mela=mela, abbr=abbr, octave=octave, unicode=unicode |
| ) |
|
|
|
|
| @deprecate_positional_args |
| def note_to_svara_c(notes, *, Sa, mela, abbr=True, octave=True, unicode=True): |
| """Convert western notes to Carnatic svara |
| |
| Note that this conversion assumes 12-tone equal temperament. |
| |
| Parameters |
| ---------- |
| notes : str or list of str |
| Notes to convert (e.g., `'C#'` or `['C4', 'Db4', 'D4']` |
| |
| Sa : str |
| Note corresponding to Sa (e.g., `'C'` or `'C5'`). |
| |
| If no octave information is provided, it will default to octave 0 |
| (``C0`` ~= 16 Hz) |
| |
| mela : str or int [1, 72] |
| Melakarta raga name or index |
| |
| abbr : bool |
| If `True` (default) return abbreviated names ('S', 'R1', 'R2', 'G1', 'G2', ...) |
| |
| If `False`, return long-form names ('Sa', 'Ri1', 'Ri2', 'Ga1', 'Ga2', ...) |
| |
| octave : bool |
| If `True`, decorate svara in neighboring octaves with over- or under-dots. |
| |
| If `False`, ignore octave height information. |
| |
| unicode : bool |
| If `True`, use unicode symbols to decorate octave information. |
| |
| If `False`, use low-order ASCII (' and ,) for octave decorations. |
| |
| This only takes effect if `octave=True`. |
| |
| Returns |
| ------- |
| svara : str or list of str |
| The svara corresponding to the given notes |
| |
| See Also |
| -------- |
| midi_to_svara_c |
| hz_to_svara_c |
| note_to_svara_h |
| note_to_midi |
| note_to_hz |
| list_mela |
| |
| Examples |
| -------- |
| >>> librosa.note_to_svara_h(['C4', 'G4', 'C5', 'D5', 'G5'], Sa='C5', mela=1) |
| ['Ṣ', 'P̣', 'S', 'G₁', 'P'] |
| """ |
| midis = note_to_midi(notes, round_midi=False) |
|
|
| return midi_to_svara_c( |
| midis, Sa=note_to_midi(Sa), mela=mela, abbr=abbr, octave=octave, unicode=unicode |
| ) |
|
|
