Ejemplo n.º 1
0
    def test_frequency_filter_gives_correct_size(self, n_frequencies, n_frames,
                                                 window_size):
        """Tests filtering signals with frequency sampling method.

    Generate random signals and magnitudes and filter using fft_convolve().

    Args:
      n_frequencies: Number of magnitudes.
      n_frames: Number of frames for a time-varying filter.
      window_size: Size of window for generating impulse responses.
    """
        # Create transfer function.
        if n_frames > 0:
            magnitudes = np.random.uniform(size=(1, n_frames,
                                                 n_frequencies)).astype(
                                                     np.float32)
        else:
            magnitudes = np.random.uniform(size=(1, n_frequencies)).astype(
                np.float32)

        audio_out = core.frequency_filter(self.audio,
                                          magnitudes,
                                          window_size=window_size,
                                          padding='same')

        audio_out_size = int(audio_out.shape[-1])
        self.assertEqual(audio_out_size, self.audio_size)
Ejemplo n.º 2
0
    def get_signal(self, audio, magnitudes):
        """Filter audio with LTV-FIR filter.

    Args:
      audio: Dry audio. 2-D Tensor of shape [batch, n_samples].
      magnitudes: Magnitudes tensor of shape [batch, n_frames, n_filter_banks].
        Expects float32 that is strictly positive.

    Returns:
      signal: Filtered audio of shape [batch, n_samples, 1].
    """
        return core.frequency_filter(audio,
                                     magnitudes,
                                     window_size=self.window_size)
Ejemplo n.º 3
0
  def get_signal(self, magnitudes):
    """Synthesize audio with filtered white noise.

    Args:
      magnitudes: Magnitudes tensor of shape [batch, n_frames, n_filter_banks].
        Expects float32 that is strictly positive.

    Returns:
      signal: A tensor of harmonic waves of shape [batch, n_samples, 1].
    """
    batch_size = int(magnitudes.shape[0])
    signal = tf.random.uniform(
        [batch_size, self.n_samples], minval=-1.0, maxval=1.0)
    return core.frequency_filter(signal,
                                 magnitudes,
                                 window_size=self.window_size)