How to control signal (red noise) generator by another one (Rocket engine effect - Subtractive synthesis of sound)

Question

I am programming some sound effects in Java and exporting them into .wav files. Currently, I am trying to program a rocket engine sound effect. I want to do it in the following way:

The sound of a rocket engine may be synthesized with a red noise generator controlled by a second red noise generator. The parameter of the first generator modified by the second one is the number of interpolated samples, influencing the spectral content of the generated noise. In order to simulate changes of sound intensity (e.g. during launch) the envelope generator should be used.

I am wondering how can it be done, e.g. what does it mean that one signal controls another one. Probably this part is explaining it, but I am not sure what to do now:

The parameter of the first generator modified by the second one is the number of interpolated samples, influencing the spectral content of the generated noise.

Is it about this parameter describing how many values from white noise are taken and linearly interpolated while creating the red noise? (see my simple drawing explaining this process below)

I have a red noise generator, which returns an array of doubles with values between -1 and 1 (it is generated from the white noise as described). What am I supposed to do now? How can I control the second red noise? I guess that it does not mean that I should control the amplitude of the second signal. Does it? Schema of steps required to obtain the rocket engine sound effect is attached below.

Answer 1

In synthesis, one would take an oscillator or waveform generator and run it through an ADSR (Attack, Decay, Sustain, Release) envelope generator and then you could modify that signal with any number of things such as a low frequency oscillator (for vibrato or similar), sync it with another oscillator or with frequency modulation, a voltage controlled filter or amplifier, etc.

From your description, you're basically taking the first RNG (which could be thought of as an oscillator on a synthesizer) and modifying it with a 2nd RNG which is, itself, modified by an EG. The Envelope Generator is providing some contour to the 2nd RNG by providing control over the Attack, Decay, Sustain and Release of the 2nd RNG. Otherwise, the RNG is just a very boring wash of broadband noise.

By modifying the 2nd RNG, you make it slightly more interesting. Applying the output of that signal to the first, you make the 1st RNG that much more interesting, as the actual sound of the 2nd RNG is no longer heard, but the application of it against the 1st RNG alters the sound of the 1st RNG, which is the only one that is actually heard. You're just using the 2nd RNG and its applied EG as a modifier for the 1st and not using its audio output directly, although you could, if so desired.

This is a good intro video to "show" you what happens when one source affects another. Here is a longer video that shows a lot more about the effects of modulating signals on a synth. The concepts are universal even though there's no specific red, white or pink noise generators used.

Here's a more complete and shorter video that has a good balance of education, entertainment and general good information on synthesis and the modulation of signals.

I hope that helps, as unless someone has actually programmed and completed what you're trying to do before and just happens to be a member of the community, it might be hard to get the answer you're looking for. Good luck with the project!

Answer 2

Using this formula, I was able to pretty closely recreate the rocket engine sound from this video (here is my version) using the following SuperCollider code:

{
  var white = WhiteNoise.ar(0.125);
  var coef = BrownNoise.ar.range(0.9, 1);
  var rocket = Fold.ar(Integrator.ar(white, coef), -1, 1);
  (rocket * 3).tanh;
}.play;

This code is a higher level of abstraction than samples, but here is what each of the unit generators do, which you can apply exactly to sample based synthesis. If you need more of a breakdown let me know.

WhiteNoise.ar(0.125) generates a random stream of samples between -0.125 and 0.125

BrownNoise.ar.range(0.9, 1) generates a stream of brownian samples (aka red noise) between 0.9 and 1

Fold.ar(xxx, -1, 1) takes a stream of samples xxx and folds them between -1 and 1 (i.e. input stream 0, 0.5, 1, 1.5, 2, 2.5, 3, 3.5 turns into 0, 0.5, 1, 0.5, 0, -0.5, -1, -0.5)

Integrator.ar(xxx, coef) takes a stream of samples and integrates them with a "leak" of coef, i.e. out(0) = in(0) + (coef * out(-1))

Pure brown noise (aka red noise) is made with Fold.ar(Integrator.ar(white, 1), -1, 1), so here I am modulating the coefficient by a brown noise source scaled between 0.9 and 1.

Then I apply some tanh distortion to the stream to mimic the distortion on the video, but you could leave that part out. It sounds much more exciting with the distortion though :)

Answer 3

I have already solved this problem: I have a white noise generated as an array of doubles:

public static double[] whiteNoise(int length) {
    double[] out = new double[length];
    for (int i = 0; i < length; i++) {
        out[i] = (Math.random() * 2 - 1.0)/2.0;
    }
    return out;
}

I obtain the red noise from the white noise in the following way:

public static double[] redNoise(int length, int m) {
    double out[] = whiteNoise(length);

    for (int i=0; i<length/m-1; i++) {
        int k = i*m;
        int l = ((i+1)*m <= length-1) ? (i+1)*m : length-1;
        double d = (out[l] - out[k])/((double)(m));
        for (int j=0; j<m; j++) {
            out[k+j] = out[k] + d*j;
        }
    }
    return out;
}

Where the m parameter is the number of interpolated samples (we take the first sample, and the m+1 sample, and interpolate values of all samples between these two).

And now the SHOW BEGINS

I generate the red noise with the interpolation number equals to let's say 10000. According to the value of consecutive samples, I alter this red noise with different values obtained from these samples taken as the interpolation number parameter. In this way a rocket sound effect is obtained.

int interpolatedframes = 10000;
    double[] rednoise1 = SigGen.redNoise(duration, interpolatedframes);
    while(i<rednoise1.length-1)
    {
        selectedNumber = (int)Math.floor(Math.abs((100*(rednoise1[i]+0.5)+100)));
        if(i+selectedNumber < rednoise1.length-1) {
            rednoise1 = SigGen.alterRedNoise(rednoise1, i, selectedNumber);
        }
        else
        {
            break;
        }
        i+=selectedNumber;
    }

With the following code the array with the noise is altered in a way, that it interpolates "interpolationNumber" of samples beginning from the startingIndex.

public static double[] alterRedNoise(double[] input, int startIndex, int interpolationNumber)
{
        int k = startIndex;
        int l = ((startIndex + interpolationNumber)<input.length-1?(startIndex+interpolationNumber):input.length-1);
        double d = (input[l] - input[k])/((double)(interpolationNumber));
        for (int j=0; j<interpolationNumber; j++) {
            input[k+j] = input[k] + d*j;
        }
    return input;
}

Sorry for a bit messy code, but I just wanted to publish it ASAP.