U 5dv@sRdZddlZddlZddlmZddlmZddlm Z ddl m Z m Z ddl mZmZdd lmZd d lmZd d lmZd d lmZd dlmZd dlmZddddddgZeedddddddddddddd ddd!d"dZeedddddddddddddd ddd!d#dZeedddddddddddddd dd$ d%dZeed&ddddddddddddd'dd( d)dZeeddddddddddddddd ddd*d+dZed,ddddej dfd-d.Z!d/d0Z"dCd2d3Z#d4d5Z$d6d7Z%eddd8d9d:Z&ed;ddddddddddd ddd?d@dZ'dAdBZ(dS)DzConstant-Q transformsN)jit)audio) get_fftlib)cqt_frequencies note_to_hz)stftistft)estimate_tuning)cache)filters)util)ParameterError)deprecate_positional_argscqt hybrid_cqt pseudo_cqticqtgriffinlim_cqtvqt)leveli"ViT g{Gz?hannTZconstant)sr hop_lengthfminn_binsbins_per_octavetuning filter_scalenormsparsitywindowscalepad_moderes_typedtypecCs(t|||||d||||| | | | | |dS)aCompute the constant-Q transform of an audio signal. This implementation is based on the recursive sub-sampling method described by [#]_. .. [#] Schoerkhuber, Christian, and Anssi Klapuri. "Constant-Q transform toolbox for music processing." 7th Sound and Music Computing Conference, Barcelona, Spain. 2010. Parameters ---------- y : np.ndarray [shape=(..., n)] audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` hop_length : int > 0 [scalar] number of samples between successive CQT columns. fmin : float > 0 [scalar] Minimum frequency. Defaults to `C1 ~= 32.70 Hz` n_bins : int > 0 [scalar] Number of frequency bins, starting at ``fmin`` bins_per_octave : int > 0 [scalar] Number of bins per octave tuning : None or float Tuning offset in fractions of a bin. If ``None``, tuning will be automatically estimated from the signal. The minimum frequency of the resulting CQT will be modified to ``fmin * 2**(tuning / bins_per_octave)``. filter_scale : float > 0 Filter scale factor. Small values (<1) use shorter windows for improved time resolution. norm : {inf, -inf, 0, float > 0} Type of norm to use for basis function normalization. See `librosa.util.normalize`. sparsity : float in [0, 1) Sparsify the CQT basis by discarding up to ``sparsity`` fraction of the energy in each basis. Set ``sparsity=0`` to disable sparsification. window : str, tuple, number, or function Window specification for the basis filters. See `filters.get_window` for details. scale : bool If ``True``, scale the CQT response by square-root the length of each channel's filter. This is analogous to ``norm='ortho'`` in FFT. If ``False``, do not scale the CQT. This is analogous to ``norm=None`` in FFT. pad_mode : string Padding mode for centered frame analysis. See also: `librosa.stft` and `numpy.pad`. res_type : string [optional] The resampling mode for recursive downsampling. By default, `cqt` will adaptively select a resampling mode which trades off accuracy at high frequencies for efficiency at low frequencies. You can override this by specifying a resampling mode as supported by `librosa.resample`. For example, ``res_type='fft'`` will use a high-quality, but potentially slow FFT-based down-sampling, while ``res_type='polyphase'`` will use a fast, but potentially inaccurate down-sampling. dtype : np.dtype The (complex) data type of the output array. By default, this is inferred to match the numerical precision of the input signal. Returns ------- CQT : np.ndarray [shape=(..., n_bins, t)] Constant-Q value each frequency at each time. See Also -------- vqt librosa.resample librosa.util.normalize Notes ----- This function caches at level 20. Examples -------- Generate and plot a constant-Q power spectrum >>> import matplotlib.pyplot as plt >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> C = np.abs(librosa.cqt(y, sr=sr)) >>> fig, ax = plt.subplots() >>> img = librosa.display.specshow(librosa.amplitude_to_db(C, ref=np.max), ... sr=sr, x_axis='time', y_axis='cqt_note', ax=ax) >>> ax.set_title('Constant-Q power spectrum') >>> fig.colorbar(img, ax=ax, format="%+2.0f dB") Limit the frequency range >>> C = np.abs(librosa.cqt(y, sr=sr, fmin=librosa.note_to_hz('C2'), ... n_bins=60)) >>> C array([[6.830e-04, 6.361e-04, ..., 7.362e-09, 9.102e-09], [5.366e-04, 4.818e-04, ..., 8.953e-09, 1.067e-08], ..., [4.288e-02, 4.580e-01, ..., 1.529e-05, 5.572e-06], [2.965e-03, 1.508e-01, ..., 8.965e-06, 1.455e-05]]) Using a higher frequency resolution >>> C = np.abs(librosa.cqt(y, sr=sr, fmin=librosa.note_to_hz('C2'), ... n_bins=60 * 2, bins_per_octave=12 * 2)) >>> C array([[5.468e-04, 5.382e-04, ..., 5.911e-09, 6.105e-09], [4.118e-04, 4.014e-04, ..., 7.788e-09, 8.160e-09], ..., [2.780e-03, 1.424e-01, ..., 4.225e-06, 2.388e-05], [5.147e-02, 6.959e-02, ..., 1.694e-05, 5.811e-06]]) r)yrrrr gammar!r"r#r$r%r&r'r(r)r*)r)r+rrrr r!r"r#r$r%r&r'r(r)r*r-:/tmp/pip-unpacked-wheel-8l90aumz/librosa/core/constantq.pyrs&cCs$|dkrtd}|dkr&t|||d}|d||}t|||d}t|}tj|||| |d\}}dtt|d|k}t t |}||}g}|dkrt ||}| t ||||||||| | | | |d |dkr| tt||||||||| | | | | |d t|||d jS) a Compute the hybrid constant-Q transform of an audio signal. Here, the hybrid CQT uses the pseudo CQT for higher frequencies where the hop_length is longer than half the filter length and the full CQT for lower frequencies. Parameters ---------- y : np.ndarray [shape=(..., n)] audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` hop_length : int > 0 [scalar] number of samples between successive CQT columns. fmin : float > 0 [scalar] Minimum frequency. Defaults to `C1 ~= 32.70 Hz` n_bins : int > 0 [scalar] Number of frequency bins, starting at ``fmin`` bins_per_octave : int > 0 [scalar] Number of bins per octave tuning : None or float Tuning offset in fractions of a bin. If ``None``, tuning will be automatically estimated from the signal. The minimum frequency of the resulting CQT will be modified to ``fmin * 2**(tuning / bins_per_octave)``. filter_scale : float > 0 Filter filter_scale factor. Larger values use longer windows. norm : {inf, -inf, 0, float > 0} Type of norm to use for basis function normalization. See `librosa.util.normalize`. sparsity : float in [0, 1) Sparsify the CQT basis by discarding up to ``sparsity`` fraction of the energy in each basis. Set ``sparsity=0`` to disable sparsification. window : str, tuple, number, or function Window specification for the basis filters. See `filters.get_window` for details. scale : bool If ``True``, scale the CQT response by square-root the length of each channel's filter. This is analogous to ``norm='ortho'`` in FFT. If ``False``, do not scale the CQT. This is analogous to ``norm=None`` in FFT. pad_mode : string Padding mode for centered frame analysis. See also: `librosa.stft` and `numpy.pad`. res_type : string Resampling mode. See `librosa.cqt` for details. dtype : np.dtype, optional The complex dtype to use for computing the CQT. By default, this is inferred to match the precision of the input signal. Returns ------- CQT : np.ndarray [shape=(..., n_bins, t), dtype=np.float] Constant-Q energy for each frequency at each time. See Also -------- cqt pseudo_cqt Notes ----- This function caches at level 20. NC1r+rr!@)rr!)freqsrr#r&alphar r) rrrr r!r#r$r%r&r'r(r*) rrrr r!r#r$r%r&r'r(r)r*)rr r__bpo_to_alphar wavelet_lengthsnpceillog2intsumminappendrabsr __trim_stackr*)r+rrrr r!r"r#r$r%r&r'r(r)r*r2r3lengths_Zpseudo_filtersZ n_bins_pseudoZ n_bins_fullcqt_respZ fmin_pseudor-r-r.rsvk  ) rrrr r!r"r#r$r%r&r'r(r*c  Cs|dkrtd}|dkr&t|||d}| dkr:t|j} |d||}t|||d}t|}tj||| ||d\}}t ||||| || | |d \}}}t |}t ||||| d| d d }| r|t |}n$tj||jd d }|t ||9}|S) aP Compute the pseudo constant-Q transform of an audio signal. This uses a single fft size that is the smallest power of 2 that is greater than or equal to the max of: 1. The longest CQT filter 2. 2x the hop_length Parameters ---------- y : np.ndarray [shape=(..., n)] audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` hop_length : int > 0 [scalar] number of samples between successive CQT columns. fmin : float > 0 [scalar] Minimum frequency. Defaults to `C1 ~= 32.70 Hz` n_bins : int > 0 [scalar] Number of frequency bins, starting at ``fmin`` bins_per_octave : int > 0 [scalar] Number of bins per octave tuning : None or float Tuning offset in fractions of a bin. If ``None``, tuning will be automatically estimated from the signal. The minimum frequency of the resulting CQT will be modified to ``fmin * 2**(tuning / bins_per_octave)``. filter_scale : float > 0 Filter filter_scale factor. Larger values use longer windows. norm : {inf, -inf, 0, float > 0} Type of norm to use for basis function normalization. See `librosa.util.normalize`. sparsity : float in [0, 1) Sparsify the CQT basis by discarding up to ``sparsity`` fraction of the energy in each basis. Set ``sparsity=0`` to disable sparsification. window : str, tuple, number, or function Window specification for the basis filters. See `filters.get_window` for details. scale : bool If ``True``, scale the CQT response by square-root the length of each channel's filter. This is analogous to ``norm='ortho'`` in FFT. If ``False``, do not scale the CQT. This is analogous to ``norm=None`` in FFT. pad_mode : string Padding mode for centered frame analysis. See also: `librosa.stft` and `numpy.pad`. dtype : np.dtype, optional The complex data type for CQT calculations. By default, this is inferred to match the precision of the input signal. Returns ------- CQT : np.ndarray [shape=(..., n_bins, t), dtype=np.float] Pseudo Constant-Q energy for each frequency at each time. Notes ----- This function caches at level 20. Nr/r0r1rr r!r2rr&r#r3)rr&r*r3rF)r&r*phasendimZaxes)rr r dtype_r2cr*rr5r r6__vqt_filter_fftr7r>__cqt_responsesqrt expand_torH)r+rrrr r!r"r#r$r%r&r'r(r*r2r3r@rA fft_basisn_fftCr-r-r.r~sVc    (fft) rrrr!r"r#r$r%r&r'lengthr)r*c % Cs|dkrtd}|d||}|jd}ttt||}t|||d}t|}tj ||| ||d\}}| dk rtt| t ||}|dd|f}t |}d}|g}|g}t |dD]`}|d d d kr| d |d d | d |d d q| d |d | d |d qtt||D]>\}\}}t||||}t|||||}t||||||| | |d \}}} |j}!dtjtt|!d d d }"|"|||9}"| rtjd|!|||"|d|ddfdd}#n"tjd|!|"|d|ddfdd}#t|#d|| d}$tj|$d||| ddd}$|dkrV|$}n|dd|$jdf|$7<q6| rtj|| d}|S)a Compute the inverse constant-Q transform. Given a constant-Q transform representation ``C`` of an audio signal ``y``, this function produces an approximation ``y_hat``. Parameters ---------- C : np.ndarray, [shape=(..., n_bins, n_frames)] Constant-Q representation as produced by `cqt` sr : number > 0 [scalar] sampling rate of the signal hop_length : int > 0 [scalar] number of samples between successive frames fmin : float > 0 [scalar] Minimum frequency. Defaults to `C1 ~= 32.70 Hz` bins_per_octave : int > 0 [scalar] Number of bins per octave tuning : float [scalar] Tuning offset in fractions of a bin. The minimum frequency of the CQT will be modified to ``fmin * 2**(tuning / bins_per_octave)``. filter_scale : float > 0 [scalar] Filter scale factor. Small values (<1) use shorter windows for improved time resolution. norm : {inf, -inf, 0, float > 0} Type of norm to use for basis function normalization. See `librosa.util.normalize`. sparsity : float in [0, 1) Sparsify the CQT basis by discarding up to ``sparsity`` fraction of the energy in each basis. Set ``sparsity=0`` to disable sparsification. window : str, tuple, number, or function Window specification for the basis filters. See `filters.get_window` for details. scale : bool If ``True``, scale the CQT response by square-root the length of each channel's filter. This is analogous to ``norm='ortho'`` in FFT. If ``False``, do not scale the CQT. This is analogous to ``norm=None`` in FFT. length : int > 0, optional If provided, the output ``y`` is zero-padded or clipped to exactly ``length`` samples. res_type : string Resampling mode. By default, this uses ``'fft'`` mode for high-quality reconstruction, but this may be slow depending on your signal duration. See `librosa.resample` for supported modes. dtype : numeric type Real numeric type for ``y``. Default is inferred to match the numerical precision of the input CQT. Returns ------- y : np.ndarray, [shape=(..., n_samples), dtype=np.float] Audio time-series reconstructed from the CQT representation. See Also -------- cqt librosa.resample Notes ----- This function caches at level 40. Examples -------- Using default parameters >>> y, sr = librosa.load(librosa.ex('trumpet')) >>> C = librosa.cqt(y=y, sr=sr) >>> y_hat = librosa.icqt(C=C, sr=sr) Or with a different hop length and frequency resolution: >>> hop_length = 256 >>> bins_per_octave = 12 * 3 >>> C = librosa.cqt(y=y, sr=sr, hop_length=256, n_bins=7*bins_per_octave, ... bins_per_octave=bins_per_octave) >>> y_hat = librosa.icqt(C=C, sr=sr, hop_length=hop_length, ... bins_per_octave=bins_per_octave) Nr/r1rFrCrD.rrr g?)r&r*r3)axiszfc,c,c,...ct->...ftT)optimizezfc,c,...ct->...ftones)r&rr*F)orig_sr target_srr)r'Zfixr4)size)rshaper:r7r8floatrr5r r6maxrLrangeinsert enumeratezipr<slicerJHZtodenser;r>ZasarrayZeinsumr rresamplerZ fix_length)%rPrrrr!r"r#r$r%r&r'rSr)r*r n_octavesr2r3r@Zf_cutoffZn_framesZC_scaler+ZsrsZhopsimy_srmy_hop n_filtersslrNrOrAZ inv_basisZ freq_powerZD_octZy_octr-r-r.rst    "  ")rrrr r,r!r"r#r$r%r&r'r(r)r*c& Csttt||}t||}|dkr0td}|dkrFt|||d}|dkrZt|j }|d||}t |||d}|| d}t |}t |}t j||| |||d\}}|d}||krtd|d|d d }|sd }|tj|krd }nd }t|||||||| \}}}g}d}|r|d kr|| d}t|||| | | |||d \}}}|t||||| |dd}d }|||}} }!t||D]}"|"dkrt| d}#nt| |"d| |"}#||#}$t| |$|| | | |||d \}}}|ddt|| 9<|t|||!|| |d|!ddkr|!d}!| d} tj|dd|d d}qt|||}%| rt j||| |||d\}}tj||%jdd}|%t|}%|%S)uCompute the variable-Q transform of an audio signal. This implementation is based on the recursive sub-sampling method described by [#]_. .. [#] Schörkhuber, Christian, Anssi Klapuri, Nicki Holighaus, and Monika Dörfler. "A Matlab toolbox for efficient perfect reconstruction time-frequency transforms with log-frequency resolution." In Audio Engineering Society Conference: 53rd International Conference: Semantic Audio. Audio Engineering Society, 2014. Parameters ---------- y : np.ndarray [shape=(..., n)] audio time series. Multi-channel is supported. sr : number > 0 [scalar] sampling rate of ``y`` hop_length : int > 0 [scalar] number of samples between successive VQT columns. fmin : float > 0 [scalar] Minimum frequency. Defaults to `C1 ~= 32.70 Hz` n_bins : int > 0 [scalar] Number of frequency bins, starting at ``fmin`` gamma : number > 0 [scalar] Bandwidth offset for determining filter lengths. If ``gamma=0``, produces the constant-Q transform. If 'gamma=None', gamma will be calculated such that filter bandwidths are equal to a constant fraction of the equivalent rectangular bandwidths (ERB). This is accomplished by solving for the gamma which gives:: B_k = alpha * f_k + gamma = C * ERB(f_k), where ``B_k`` is the bandwidth of filter ``k`` with center frequency ``f_k``, alpha is the inverse of what would be the constant Q-factor, and ``C = alpha / 0.108`` is the constant fraction across all filters. Here we use ``ERB(f_k) = 24.7 + 0.108 * f_k``, the best-fit curve derived from experimental data in [#]_. .. [#] Glasberg, Brian R., and Brian CJ Moore. "Derivation of auditory filter shapes from notched-noise data." Hearing research 47.1-2 (1990): 103-138. bins_per_octave : int > 0 [scalar] Number of bins per octave tuning : None or float Tuning offset in fractions of a bin. If ``None``, tuning will be automatically estimated from the signal. The minimum frequency of the resulting VQT will be modified to ``fmin * 2**(tuning / bins_per_octave)``. filter_scale : float > 0 Filter scale factor. Small values (<1) use shorter windows for improved time resolution. norm : {inf, -inf, 0, float > 0} Type of norm to use for basis function normalization. See `librosa.util.normalize`. sparsity : float in [0, 1) Sparsify the VQT basis by discarding up to ``sparsity`` fraction of the energy in each basis. Set ``sparsity=0`` to disable sparsification. window : str, tuple, number, or function Window specification for the basis filters. See `filters.get_window` for details. scale : bool If ``True``, scale the VQT response by square-root the length of each channel's filter. This is analogous to ``norm='ortho'`` in FFT. If ``False``, do not scale the VQT. This is analogous to ``norm=None`` in FFT. pad_mode : string Padding mode for centered frame analysis. See also: `librosa.stft` and `numpy.pad`. res_type : string [optional] The resampling mode for recursive downsampling. By default, `vqt` will adaptively select a resampling mode which trades off accuracy at high frequencies for efficiency at low frequencies. You can override this by specifying a resampling mode as supported by `librosa.resample`. For example, ``res_type='fft'`` will use a high-quality, but potentially slow FFT-based down-sampling, while ``res_type='polyphase'`` will use a fast, but potentially inaccurate down-sampling. dtype : np.dtype The dtype of the output array. By default, this is inferred to match the numerical precision of the input signal. Returns ------- VQT : np.ndarray [shape=(..., n_bins, t), dtype=np.complex] Variable-Q value each frequency at each time. See Also -------- cqt Notes ----- This function caches at level 20. Examples -------- Generate and plot a variable-Q power spectrum >>> import matplotlib.pyplot as plt >>> y, sr = librosa.load(librosa.ex('choice'), duration=5) >>> C = np.abs(librosa.cqt(y, sr=sr)) >>> V = np.abs(librosa.vqt(y, sr=sr)) >>> fig, ax = plt.subplots(nrows=2, sharex=True, sharey=True) >>> librosa.display.specshow(librosa.amplitude_to_db(C, ref=np.max), ... sr=sr, x_axis='time', y_axis='cqt_note', ax=ax[0]) >>> ax[0].set(title='Constant-Q power spectrum', xlabel=None) >>> ax[0].label_outer() >>> img = librosa.display.specshow(librosa.amplitude_to_db(V, ref=np.max), ... sr=sr, x_axis='time', y_axis='cqt_note', ax=ax[1]) >>> ax[1].set_title('Variable-Q power spectrum') >>> fig.colorbar(img, ax=ax, format="%+2.0f dB") Nr/r0r1)r rr!)r2rr&r#r,r3z!Wavelet basis with max frequency=z$ would exceed the Nyquist frequency=z,. Try reducing the number of frequency bins.FT kaiser_fastZ kaiser_bestr)r&r,r*r3r*rr rWrXr)r'rFrG)r:r7r8r[r<rr rrIr*rr\r5r r6rr BW_FASTEST__early_downsamplerJr=rKr]rarLrcr?rMrH)&r+rrrr r,r!r"r#r$r%r&r'r(r)r*rdrhr2Z freqs_topZfmax_tr3r@ filter_cutoffnyquistZ auto_resampleZvqt_respZ oct_startrNrOrAZmy_yrfrgreriZ freqs_octVr-r-r.rs!            c  Cstj||||d||| d\} } | jd} |dk rh| ddtt|krhtddtt|} | | ddtjft| 9} t } | j | | ddddd| ddf}t j |||d}|| | fS) z6Generate the frequency domain variable-Q filter basis.T)r2rr#r$Zpad_fftr&r,r3rNr1)nrTr )Zquantiler*) r ZwaveletrZr7r8r9r:Znewaxisr[rrRrZ sparsify_rows)rr2r#r$r%rr&r,r*r3Zbasisr@rOrRrNr-r-r.rJ.s$ $(rJc Cstdd|D}t|dj}||d<||d<tj||dd}|}|D]p}|jd}||kr|d| d d |f|dd |d d f<n&|dd |f|d|||d d f<||8}qH|S) z?Helper function to trim and stack a collection of CQT responsescss|]}|jdVqdS)r4N)rZ).0c_ir-r-r. ^sz__trim_stack..rrFr4F)r*order.N)r<listrZr7empty) rBr r*Zmax_colrZZcqt_outendruZn_octr-r-r.r?[s ,& r?rVc Cst||||||d}|s"t|}|d|jd|jdf} tj| jd|jd| jdf|jd} t| jdD]} || | | | <qtt |j} |jd| d<| | S)z3Compute the filter response with a target STFT hop.)rOrr&r(r*r4rFrrk) rr7r>ZreshaperZrzr*r]dotry) r+rOrrNmoder&rEr*DZDrZ output_flatrerZr-r-r.rKvs(  rKc CsPtdttttj||dd}t|}td||d}t||S)z3Compute the number of early downsampling operationsrr) r\r:r7r8r9rrm__num_two_factorsr<)rprorrdZdownsample_count1num_twosZdownsample_count2r-r-r.__early_downsample_counts$rc Cst||||}|dkr|dkrd|} || }|jd| krPtdt|||t| } tj||| |dd}|s|t | 9}| }|||fS)z=Perform early downsampling on an audio signal, if it applies.rrjr r4z9Input signal length={:d} is too short for {:d}-octave CQTTrl) rrZrformatlenr[rrcr7rL) r+rrr)rdrpror'Zdownsample_countZdownsample_factorZnew_srr-r-r.rns8 rn)Znopythonr cCs2|dkr dSd}|ddkr.|d7}|d}q|S)zjReturn how many times integer x can be evenly divided by 2. Returns 0 for non-positive integers. rr rr-)xrr-r-r.rs  r rjgGz?random)n_iterrrrr!r"r#r$r%r&r'r(r)r*rSmomentuminit random_statecCs|dkrtd}|dkr tj}n,t|tr:tjj|d}nt|tjjrL|}|dkrjtjd|ddn|dkrt d |tj |j tj d }t |}|d krtd tj|j|j |dd<n$|dkrd |dd<nt d|d}t|D]}|}t||||||||| || || | |d}t||||j d||||| || | | | d}||d|||dd<|ddt||<qt||||||||| || || | |dS)uApproximate constant-Q magnitude spectrogram inversion using the "fast" Griffin-Lim algorithm. Given the magnitude of a constant-Q spectrogram (``C``), the algorithm randomly initializes phase estimates, and then alternates forward- and inverse-CQT operations. [#]_ This implementation is based on the (fast) Griffin-Lim method for Short-time Fourier Transforms, [#]_ but adapted for use with constant-Q spectrograms. .. [#] D. W. Griffin and J. S. Lim, "Signal estimation from modified short-time Fourier transform," IEEE Trans. ASSP, vol.32, no.2, pp.236–243, Apr. 1984. .. [#] Perraudin, N., Balazs, P., & Søndergaard, P. L. "A fast Griffin-Lim algorithm," IEEE Workshop on Applications of Signal Processing to Audio and Acoustics (pp. 1-4), Oct. 2013. Parameters ---------- C : np.ndarray [shape=(..., n_bins, n_frames)] The constant-Q magnitude spectrogram n_iter : int > 0 The number of iterations to run sr : number > 0 Audio sampling rate hop_length : int > 0 The hop length of the CQT fmin : number > 0 Minimum frequency for the CQT. If not provided, it defaults to `C1`. bins_per_octave : int > 0 Number of bins per octave tuning : float Tuning deviation from A440, in fractions of a bin filter_scale : float > 0 Filter scale factor. Small values (<1) use shorter windows for improved time resolution. norm : {inf, -inf, 0, float > 0} Type of norm to use for basis function normalization. See `librosa.util.normalize`. sparsity : float in [0, 1) Sparsify the CQT basis by discarding up to ``sparsity`` fraction of the energy in each basis. Set ``sparsity=0`` to disable sparsification. window : str, tuple, or function Window specification for the basis filters. See `filters.get_window` for details. scale : bool If ``True``, scale the CQT response by square-root the length of each channel's filter. This is analogous to ``norm='ortho'`` in FFT. If ``False``, do not scale the CQT. This is analogous to ``norm=None`` in FFT. pad_mode : string Padding mode for centered frame analysis. See also: `librosa.stft` and `numpy.pad`. res_type : string The resampling mode for recursive downsampling. By default, CQT uses an adaptive mode selection to trade accuracy at high frequencies for efficiency at low frequencies. Griffin-Lim uses the efficient (fast) resampling mode by default. See ``librosa.resample`` for a list of available options. dtype : numeric type Real numeric type for ``y``. Default is inferred to match the precision of the input CQT. length : int > 0, optional If provided, the output ``y`` is zero-padded or clipped to exactly ``length`` samples. momentum : float > 0 The momentum parameter for fast Griffin-Lim. Setting this to 0 recovers the original Griffin-Lim method. Values near 1 can lead to faster convergence, but above 1 may not converge. init : None or 'random' [default] If 'random' (the default), then phase values are initialized randomly according to ``random_state``. This is recommended when the input ``C`` is a magnitude spectrogram with no initial phase estimates. If ``None``, then the phase is initialized from ``C``. This is useful when an initial guess for phase can be provided, or when you want to resume Griffin-Lim from a previous output. random_state : None, int, or np.random.RandomState If int, random_state is the seed used by the random number generator for phase initialization. If `np.random.RandomState` instance, the random number generator itself. If ``None``, defaults to the current `np.random` object. Returns ------- y : np.ndarray [shape=(..., n)] time-domain signal reconstructed from ``C`` See Also -------- cqt icqt griffinlim filters.get_window resample Examples -------- A basis CQT inverse example >>> y, sr = librosa.load(librosa.ex('trumpet', hq=True), sr=None) >>> # Get the CQT magnitude, 7 octaves at 36 bins per octave >>> C = np.abs(librosa.cqt(y=y, sr=sr, bins_per_octave=36, n_bins=7*36)) >>> # Invert using Griffin-Lim >>> y_inv = librosa.griffinlim_cqt(C, sr=sr, bins_per_octave=36) >>> # And invert without estimating phase >>> y_icqt = librosa.icqt(C, sr=sr, bins_per_octave=36) Wave-plot the results >>> import matplotlib.pyplot as plt >>> fig, ax = plt.subplots(nrows=3, sharex=True, sharey=True) >>> librosa.display.waveshow(y, sr=sr, color='b', ax=ax[0]) >>> ax[0].set(title='Original', xlabel=None) >>> ax[0].label_outer() >>> librosa.display.waveshow(y_inv, sr=sr, color='g', ax=ax[1]) >>> ax[1].set(title='Griffin-Lim reconstruction', xlabel=None) >>> ax[1].label_outer() >>> librosa.display.waveshow(y_icqt, sr=sr, color='r', ax=ax[2]) >>> ax[2].set(title='Magnitude-only icqt reconstruction') Nr/)seedrzGGriffin-Lim with momentum={} > 1 can be unstable. Proceed with caution!r ) stacklevelrz,griffinlim_cqt() called with momentum={} < 0rkry@g?z$init={} must either None or 'random'r) rrr!rr"r#r&rSr)r$r'r%r*rF) rr!r rrr"r#r&r$r'r%r(r)) rrr!r"r#rr&rSr)r$r'r%r*)rr7r isinstancer:Z RandomStatewarningswarnrrrzrZ complex64rZtinyexppiZrandr]rrr>)rPrrrrr!r"r#r$r%r&r'r(r)r*rSrrrrngZanglesZepsZrebuiltrAZtprevZinverser-r-r.rs1  &  cCs$dd|}|dd|ddS)zCompute the alpha coefficient for a given number of bins per octave Parameters ---------- bins_per_octave : int Returns ------- alpha : number > 0 r rr-)r!rr-r-r.r5s r5)rVTN))__doc__rZnumpyr7ZnumbarrrRrconvertrrZspectrumrr Zpitchr _cacher r rZutil.exceptionsrZutil.decoratorsr__all__rrrrrrrJr?rKrrnrrr5r-r-r-r.s         -7`2 ,  #