soundgen (version 1.3.0)

generateNoise: Generate noise

Description

Generates noise of length len and with spectrum defined by linear decay of rolloffNoise dB/kHz above noiseFlatSpec Hz OR by a specified filter filterNoise. This function is called internally by soundgen, but it may be more convenient to call it directly when synthesizing non-biological noises defined by specific spectral and amplitude envelopes rather than formants: the wind, whistles, impact noises, etc. See fart and beat for similarly simplified functions for voiced non-biological sounds.

Usage

generateNoise(len, rolloffNoise = 0, noiseFlatSpec = 1200,
  filterNoise = NULL, noiseAnchors = NULL, temperature = 0.1,
  attackLen = 10, windowLength_points = 1024, samplingRate = 16000,
  overlap = 75, dynamicRange = 80)

Arguments

len

length of output

rolloffNoise

linear rolloff of the excitation source for the unvoiced component, dB/kHz (anchor format)

noiseFlatSpec

keeps noise spectrum flat to this frequency, Hz

filterNoise

(optional): as an alternative to using rolloffNoise, we can provide the exact filter - a vector of non-negative numbers specifying the power in each frequency bin on a linear scale (interpolated to length equal to windowLength_points/2). A matrix specifying the filter for each STFT step is also accepted. The easiest way to create this matrix is to call soundgen:::getSpectralEnvelope, but then you might as well just use soundgen()

noiseAnchors

loudness of turbulent noise (0 dB = as loud as voiced component, negative values = quieter) such as aspiration, hissing, etc (anchor format)

temperature

hyperparameter for regulating the amount of stochasticity in sound generation

attackLen

duration of fade-in / fade-out at each end of syllables and noise (ms): a vector of length 1 (symmetric) or 2 (separately for fade-in and fade-out)

windowLength_points

the length of fft window, points

samplingRate

sampling frequency, Hz

overlap

FFT window overlap, %. For allowed values, see istft

dynamicRange

dynamic range, dB. Harmonics and noise more than dynamicRange under maximum amplitude are discarded to save computational resources

Details

Algorithm: paints a spectrum with desired characteristics, sets phase to zero, and generates a time sequence via inverse FFT. Noise can then be used as an additional source to be added to the glottal source AFTER the glottal source has been formant-filtered, or BEFORE formant-filtering for glottal breathing noise.

Examples

# NOT RUN {
# .5 s of white noise
samplingRate = 16000
noise1 = generateNoise(len = samplingRate * .5,
  samplingRate = samplingRate)
# playme(noise1, samplingRate)
# seewave::meanspec(noise1, f = samplingRate)

# Percussion (run a few times to notice stochasticity due to temperature = .25)
noise2 = generateNoise(len = samplingRate * .15, noiseAnchors = c(0, -80),
  rolloffNoise = c(4, -6), attackLen = 5, temperature = .25)
noise3 = generateNoise(len = samplingRate * .25, noiseAnchors = c(0, -40),
  rolloffNoise = c(4, -24), attackLen = 5, temperature = .25)
# playme(c(noise2, noise3), samplingRate)

# }
# NOT RUN {
# 1.2 s of noise with rolloff changing from 0 to -12 dB above 2 kHz
noise = generateNoise(len = samplingRate * 1.2,
  rolloffNoise = c(0, -12), noiseFlatSpec = 2000, samplingRate = samplingRate)
# playme(noise, samplingRate = samplingRate)
# spectrogram(noise, samplingRate, osc = TRUE)

# Similar, but using the dataframe format to specify a more complicated
# contour for rolloffNoise:
noise = generateNoise(len = samplingRate * 1.2,
  rolloffNoise = data.frame(time = c(0, .2, 1), value = c(-12, 0, -12)),
  noiseFlatSpec = 2000, samplingRate = samplingRate)
# playme(noise, samplingRate = samplingRate)
# spectrogram(noise, samplingRate, osc = TRUE)

# To create a sibilant [s], specify a single strong, broad formant at ~7 kHz:
windowLength_points = 1024
filterNoise = soundgen:::getSpectralEnvelope(
  nr = windowLength_points / 2, nc = 1, samplingRate = samplingRate,
 formants = list('f1' = data.frame(time = 0, freq = 7000,
                                   amp = 50, width = 2000)))
noise = generateNoise(len = samplingRate,
  samplingRate = samplingRate, filterNoise = as.numeric(filterNoise))
# plot(filterNoise, type = 'l')
# playme(noise, samplingRate = samplingRate)

# Low-frequency, wind-like noise
filterNoise = soundgen:::getSpectralEnvelope(
  nr = windowLength_points / 2, nc = 1, lipRad = 0,
  samplingRate = samplingRate, formants = list('f1' = data.frame(
    time = 0, freq = 150, amp = 30, width = 90)))
noise = generateNoise(len = samplingRate,
  samplingRate = samplingRate, filterNoise = as.numeric(filterNoise))
# playme(noise, samplingRate = samplingRate)

# Manual filter, e.g. for a kettle-like whistle (narrow-band noise)
filterNoise = c(rep(0, 100), 120, rep(0, 100))  # any length is fine
# plot(filterNoise, type = 'b')  # notch filter at Nyquist / 2, here 4 kHz
noise = generateNoise(len = samplingRate,
  samplingRate = samplingRate, filterNoise = filterNoise)
# playme(noise, samplingRate = samplingRate)
# spectrogram(noise, samplingRate)

# Compare to a similar sound created with soundgen()
# (unvoiced only, a single formant at 4 kHz)
noise_s = soundgen(pitchAnchors = NULL,
  noiseAnchors = data.frame(time = c(0, 1000), value = c(0, 0)),
  formants = list(f1 = data.frame(freq = 4000, amp = 80, width = 20)))
# playme(noise_s)
# }