Python源码示例:hparams.hparams.ref_level_db()

示例1
def forward(self, x):
        if self.preemp is not None:
            x = x.unsqueeze(1)
            x = self.preemp(x)
            x = x.squeeze(1)
        stft = torch.stft(x,
                          self.win_length,
                          self.hop_length,
                          fft_size=self.n_fft,
                          window=self.win)
        real = stft[:, :, :, 0]
        im = stft[:, :, :, 1]
        spec = torch.sqrt(torch.pow(real, 2) + torch.pow(im, 2))

        # convert linear spec to mel
        mel = torch.matmul(spec, self.mel_basis)
        # convert to db
        mel = _amp_to_db(mel) - hparams.ref_level_db
        return _normalize(mel) 
示例2
def spectrogram(y):
    D = _stft(_preemphasis(y))
    S = _amp_to_db(np.abs(D)) - hparams.ref_level_db
    return _normalize(S) 
示例3
def inv_spectrogram(spectrogram):
    S = _db_to_amp(_denormalize(spectrogram) + hparams.ref_level_db)  # Convert back to linear
    return _inv_preemphasis(_griffin_lim(S ** hparams.power))  # Reconstruct phase 
示例4
def inv_spectrogram(spectrogram):
    S = _db_to_amp(_denormalize(spectrogram) + hparams.ref_level_db)  # Convert back to linear
    return _inv_preemphasis(spectrogram2wav(S ** hparams.power))  # Reconstruct phase 
示例5
def spectrogram(y):
  D = _stft(preemphasis(y))
  S = _amp_to_db(np.abs(D)) - hparams.ref_level_db
  return _normalize(S) 
示例6
def inv_spectrogram(spectrogram):
  '''Converts spectrogram to waveform using librosa'''
  S = _db_to_amp(_denormalize(spectrogram) + hparams.ref_level_db)  # Convert back to linear
  return inv_preemphasis(_griffin_lim(S ** hparams.power))          # Reconstruct phase 
示例7
def inv_spectrogram_tensorflow(spectrogram):
  '''Builds computational graph to convert spectrogram to waveform using TensorFlow.

  Unlike inv_spectrogram, this does NOT invert the preemphasis. The caller should call
  inv_preemphasis on the output after running the graph.
  '''
  S = _db_to_amp_tensorflow(_denormalize_tensorflow(spectrogram) + hparams.ref_level_db)
  return _griffin_lim_tensorflow(tf.pow(S, hparams.power)) 
示例8
def melspectrogram(y):
  D = _stft(preemphasis(y))
  S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db
  return _normalize(S) 
示例9
def linearspectrogram(wav):
	D = _stft(wav)
	S = _amp_to_db(np.abs(D)) - hparams.ref_level_db

	if hparams.signal_normalization:
		return _normalize(S)
	return S 
示例10
def melspectrogram(wav):
	D = _stft(wav)
	S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db

	if hparams.signal_normalization:
		return _normalize(S)
	return S 
示例11
def inv_linear_spectrogram(linear_spectrogram):
	'''Converts linear spectrogram to waveform using librosa'''
	if hparams.signal_normalization:
		D = _denormalize(linear_spectrogram)
	else:
		D = linear_spectrogram

	S = _db_to_amp(D + hparams.ref_level_db) #Convert back to linear

	return _griffin_lim(S ** hparams.power) 
示例12
def inv_mel_spectrogram(mel_spectrogram):
	'''Converts mel spectrogram to waveform using librosa'''
	if hparams.signal_normalization:
		D = _denormalize(mel_spectrogram)
	else:
		D = mel_spectrogram

	S = _mel_to_linear(_db_to_amp(D + hparams.ref_level_db))  # Convert back to linear

	return _griffin_lim(S ** hparams.power) 
示例13
def melspectrogram(wav):
	D = _stft(wav)
	S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db

	if hparams.mel_normalization:
		return _normalize(S)
	return S 
示例14
def spectrogram(y):
  D = _stft(preemphasis(y))
  S = _amp_to_db(np.abs(D)) - hparams.ref_level_db
  return _normalize(S) 
示例15
def inv_spectrogram(spectrogram):
  '''Converts spectrogram to waveform using librosa'''
  S = _db_to_amp(_denormalize(spectrogram) + hparams.ref_level_db)  # Convert back to linear
  return inv_preemphasis(_griffin_lim(S ** hparams.power))          # Reconstruct phase 
示例16
def inv_spectrogram_tensorflow(spectrogram):
  '''Builds computational graph to convert spectrogram to waveform using TensorFlow.

  Unlike inv_spectrogram, this does NOT invert the preemphasis. The caller should call
  inv_preemphasis on the output after running the graph.
  '''
  S = _db_to_amp_tensorflow(_denormalize_tensorflow(spectrogram) + hparams.ref_level_db)
  return _griffin_lim_tensorflow(tf.pow(S, hparams.power)) 
示例17
def melspectrogram(y):
  D = _stft(preemphasis(y))
  S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db
  return _normalize(S) 
示例18
def melspectrogram(y):
    D = _stft(y)
    S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db
    if not hparams.allow_clipping_in_normalization:
        assert S.max() <= 0 and S.min() - hparams.min_level_db >= 0
    return _normalize(S) 
示例19
def spectrogram(y):
    D = _stft(y)
    S = _amp_to_db(np.abs(D)) - hparams.ref_level_db
    return _normalize(S) 
示例20
def forward(self, x):
        if self.preemp is not None:
            x = x.unsqueeze(1)
            # conv and remove last padding
            x = self.preemp(x)[:, :, :-1]
            x = x.squeeze(1)

        # center=True
        # torch 0.4 doesnt support like librosa
        signal_dim = x.dim()
        extended_shape = [1] * (3 - signal_dim) + list(x.size())
        # pad = int(self.n_fft // 2)
        pad = self.win_length
        x = F.pad(x.view(extended_shape), (pad, pad), 'constant')
        x = x.view(x.shape[-signal_dim:])
        stft = torch.stft(x,
                          self.win_length,
                          self.hop_length,
                          window=self.win,
                          fft_size=self.n_fft)
        real = stft[:, :, :, 0]
        im = stft[:, :, :, 1]
        p = torch.sqrt(torch.pow(real, 2) + torch.pow(im, 2))

        # convert volume to db
        spec = _amp_to_db(p) - hparams.ref_level_db
        return spec, p 
示例21
def spectrogram(y):
  D = _stft(preemphasis(y))
  S = _amp_to_db(np.abs(D)) - hparams.ref_level_db
  return _normalize(S) 
示例22
def inv_spectrogram(spectrogram):
  '''Converts spectrogram to waveform using librosa'''
  S = _db_to_amp(_denormalize(spectrogram) + hparams.ref_level_db)  # Convert back to linear
  return inv_preemphasis(_griffin_lim(S ** hparams.power))          # Reconstruct phase 
示例23
def inv_spectrogram_tensorflow(spectrogram):
  '''Builds computational graph to convert spectrogram to waveform using TensorFlow.

  Unlike inv_spectrogram, this does NOT invert the preemphasis. The caller should call
  inv_preemphasis on the output after running the graph.
  '''
  S = _db_to_amp_tensorflow(_denormalize_tensorflow(spectrogram) + hparams.ref_level_db)
  return _griffin_lim_tensorflow(tf.pow(S, hparams.power)) 
示例24
def melspectrogram(y):
  D = _stft(preemphasis(y))
  S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db
  return _normalize(S) 
示例25
def spectrogram(y):
    D = _lws_processor().stft(preemphasis(y)).T
    S = _amp_to_db(np.abs(D)) - hparams.ref_level_db
    return _normalize(S) 
示例26
def inv_spectrogram(spectrogram):
    '''Converts spectrogram to waveform using librosa'''
    S = _db_to_amp(_denormalize(spectrogram) + hparams.ref_level_db)  # Convert back to linear
    processor = _lws_processor()
    D = processor.run_lws(S.astype(np.float64).T ** hparams.power)
    y = processor.istft(D).astype(np.float32)
    return inv_preemphasis(y) 
示例27
def melspectrogram(y):
    D = _lws_processor().stft(preemphasis(y)).T
    S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db
    if not hparams.allow_clipping_in_normalization:
        assert S.max() <= 0 and S.min() - hparams.min_level_db >= 0
    return _normalize(S) 
示例28
def linearspectrogram(wav):
	D = _stft(wav)
	S = _amp_to_db(np.abs(D)) - hparams.ref_level_db

	if hparams.signal_normalization:
		return _normalize(S)
	return S 
示例29
def melspectrogram(wav):
	D = _stft(wav)
	S = _amp_to_db(_linear_to_mel(np.abs(D))) - hparams.ref_level_db

	if hparams.signal_normalization:
		return _normalize(S)
	return S 
示例30
def inv_linear_spectrogram(linear_spectrogram):
	'''Converts linear spectrogram to waveform using librosa'''
	if hparams.signal_normalization:
		D = _denormalize(linear_spectrogram)
	else:
		D = linear_spectrogram

	S = _db_to_amp(D + hparams.ref_level_db) #Convert back to linear

	return _griffin_lim(S ** hparams.power)