| import torch |
| import numpy as np |
| import librosa.util as librosa_util |
|
|
| from scipy.signal import get_window |
| from scipy.io.wavfile import read |
| from maha_tts.config import config |
|
|
| TACOTRON_MEL_MAX = 2.4 |
| TACOTRON_MEL_MIN = -11.5130 |
|
|
|
|
| def denormalize_tacotron_mel(norm_mel): |
| return ((norm_mel+1)/2)*(TACOTRON_MEL_MAX-TACOTRON_MEL_MIN)+TACOTRON_MEL_MIN |
|
|
|
|
| def normalize_tacotron_mel(mel): |
| return 2 * ((mel - TACOTRON_MEL_MIN) / (TACOTRON_MEL_MAX - TACOTRON_MEL_MIN)) - 1 |
|
|
|
|
| def get_mask_from_lengths(lengths, max_len=None): |
| if not max_len: |
| max_len = torch.max(lengths).item() |
| ids = torch.arange(0, max_len, device=lengths.device, dtype=torch.long) |
| mask = (ids < lengths.unsqueeze(1)).bool() |
| return mask |
|
|
|
|
| def get_mask(lengths, max_len=None): |
| if not max_len: |
| max_len = torch.max(lengths).item() |
| lens = torch.arange(max_len,) |
| mask = lens[:max_len].unsqueeze(0) < lengths.unsqueeze(1) |
| return mask |
|
|
|
|
|
|
| def dynamic_range_compression(x, C=1, clip_val=1e-5): |
| """ |
| PARAMS |
| ------ |
| C: compression factor |
| """ |
| return torch.log(torch.clamp(x, min=clip_val) * C) |
|
|
|
|
| def dynamic_range_decompression(x, C=1): |
| """ |
| PARAMS |
| ------ |
| C: compression factor used to compress |
| """ |
| return torch.exp(x) / C |
|
|
|
|
| def window_sumsquare(window, n_frames, hop_length=200, win_length=800, |
| n_fft=800, dtype=np.float32, norm=None): |
| """ |
| # from librosa 0.6 |
| Compute the sum-square envelope of a window function at a given hop length. |
| This is used to estimate modulation effects induced by windowing |
| observations in short-time fourier transforms. |
| Parameters |
| ---------- |
| window : string, tuple, number, callable, or list-like |
| Window specification, as in `get_window` |
| n_frames : int > 0 |
| The number of analysis frames |
| hop_length : int > 0 |
| The number of samples to advance between frames |
| win_length : [optional] |
| The length of the window function. By default, this matches `n_fft`. |
| n_fft : int > 0 |
| The length of each analysis frame. |
| dtype : np.dtype |
| The data type of the output |
| Returns |
| ------- |
| wss : np.ndarray, shape=`(n_fft + hop_length * (n_frames - 1))` |
| The sum-squared envelope of the window function |
| """ |
| if win_length is None: |
| win_length = n_fft |
|
|
| n = n_fft + hop_length * (n_frames - 1) |
| x = np.zeros(n, dtype=dtype) |
|
|
| |
| win_sq = get_window(window, win_length, fftbins=True) |
| win_sq = librosa_util.normalize(win_sq, norm=norm)**2 |
| win_sq = librosa_util.pad_center(win_sq, size=n_fft) |
|
|
| |
| for i in range(n_frames): |
| sample = i * hop_length |
| x[sample:min(n, sample + n_fft)] += win_sq[:max(0, min(n_fft, n - sample))] |
| return x |
|
|
| def load_wav_to_torch(full_path): |
| sampling_rate, data = read(full_path,) |
| return torch.FloatTensor(data), sampling_rate |
|
|
|
|
|
|
| if __name__ == "__main__": |
| lens = torch.tensor([2, 3, 7, 5, 4]) |
| mask = get_mask(lens) |
| print(mask) |
| print(mask.shape) |
