How do I detune an audio sample by 1 hertz up or down from a copy of it

Question

I have a program that can take a waveform, such as a sine wave or sawtooth wave and detune it with another waveform that is slightly sharper or flatter. It takes the frequency of said waveform and adds or subtracts the amount of hertz to detune from it depending on which threads are activated. If I have a sine wave at 261.62Hz (middle C), and detune it to three threads - one sharp, one flat and one still at unison pitch (no change) - I end up with a detuned sine wave.

Now if I have a PCM audio sample (say a wave file of a trumpet with loop points) at middle C pitch with a play sample rate of 44100, how do I calculate the amount to add to or subtract from the play sample rate to detune it one hertz? How do I do this with other sample rates?

I need a formula that can detune the PCM sampled data at any sample rate to detune any possible threads up or down by one hertz.

Code for detuner

public class Detuner implements ISample {

    // constants
    public static final double DEF_DETUNING_VALUE = 0;
    public static final boolean DEF_UNNISON_TUNING = true;
    public static final boolean DEF_DETUNING = false;
    public static final byte DEF_DETUNE_THREADS = 1;

    // instance variables
    private double celesteTuning;           // frequency to offset the tuning by
    private boolean sharpTuning;            // turns on sharp tuning
    private boolean flatTuning;             // turns on flat tuning
    private boolean unisonTuning;           // turns on unison tuning
    private double unisonToDetuningRatio;   // defines how loud the unison is to the detuning
    private double detuningToProcess;       // use in certain scenarios
    private ISample baseWaveform;           // the base waveform
    private ISample[] sharpWaveforms;       // sharp
    private ISample[] flatWaveforms;        // flat
    private ISample unisonWaveGeneration;   // uninson
    private byte detuneThreads;             // number of threads for each detune side
    private double averageThreadDetuneAmount;   // the amount to add on each thread
    private double unisonFrequency;
    private AdsrEnvelope adsrEnvelope;

    // constructor
    public Detuner(double celesteTuning, boolean sharpTuning,
            boolean flatTuning, boolean unisonTuning,
            double unisonToDetuningRatio, ISample detuneWaveform,
            byte detuneThreads)
            throws CloneNotSupportedException {
        this.celesteTuning = celesteTuning;
        this.sharpTuning = sharpTuning;
        this.flatTuning = flatTuning;
        this.unisonTuning = unisonTuning;
        this.unisonToDetuningRatio = unisonToDetuningRatio;
        this.detuneThreads = detuneThreads;

        // if sharp, flat and unison tunings are used
        if (sharpTuning && flatTuning && !unisonTuning) {

            // detuningToProcess is celesteTuning / 2
            detuningToProcess = celesteTuning / 2;
        } // otherwise it is celesteTuning
        else {
            detuningToProcess = celesteTuning;
        }

        // set average thread detune and offset amount
        averageThreadDetuneAmount = detuningToProcess / detuneThreads;

        baseWaveform = (ISample) detuneWaveform;

        unisonFrequency = baseWaveform.getFrequency();

        // random offset to frequency
        double randomFrequencyOffset;

        // if unnison to detuning ratio is zero set it to division of all threads
        if (unisonToDetuningRatio == 0) {
            int totalThreads = detuneThreads;

            if (sharpTuning && flatTuning) {
                totalThreads *= 2;
            }

            // increment for unison thread
            totalThreads++;

            this.unisonToDetuningRatio = (double) 1 / (double) totalThreads;
        }

        if (sharpTuning) {

            // detuning holder
            double detuningHolder = averageThreadDetuneAmount;

            // initialise the array
            sharpWaveforms = new ISample[detuneThreads];

            // define averate amount to add to each thread
            for (int i = 0; i < sharpWaveforms.length; i++) {
                sharpWaveforms[i] = (ISample) baseWaveform.clone();
                if (i == 0) {
                    randomFrequencyOffset = detuningToProcess;
                } else {
                    randomFrequencyOffset = detuningHolder
                            + (Math.random() * averageThreadDetuneAmount
                            - averageThreadDetuneAmount / 2 / detuneThreads);
                    detuningHolder += averageThreadDetuneAmount;
                }
                // if it is an audio sample up the play sample rate
                if (baseWaveform instanceof SamplePlayer) {
                    // formula should go here and extract the sample rate of the sample player
                }
                sharpWaveforms[i].addToFrequency(randomFrequencyOffset);
                if (detuneThreads != 1) {
                    sharpWaveforms[i].setOffset(Math.random());
                }
            }
        }

        if (flatTuning) {

            // detuning holder
            double detuningHolder = averageThreadDetuneAmount;

            // initialise the array
            flatWaveforms = new ISample[detuneThreads];

            // define averate amount to add to each thread
            for (int i = 0; i < flatWaveforms.length; i++) {
                flatWaveforms[i] = (ISample) baseWaveform.clone();
                if (i == 0) {
                    randomFrequencyOffset = detuningToProcess;
                } else {
                    randomFrequencyOffset = detuningHolder
                            + (Math.random() * averageThreadDetuneAmount
                            - averageThreadDetuneAmount / 2 / detuneThreads);
                    detuningHolder += averageThreadDetuneAmount;
                }
                // if it is an audio sample up the play sample rate
                if (baseWaveform instanceof SamplePlayer) {
                    // formula also goes here
                }
                flatWaveforms[i].subtractFromFrequency(randomFrequencyOffset);
                if (detuneThreads != 1) {
                    flatWaveforms[i].setOffset(Math.random());
                }
            }
        }

        if (unisonTuning) {
            unisonWaveGeneration = (ISample) baseWaveform;
        }
    }
```

Answer 1

If you change the sampling rate, then all frequencies will scale proportionally by the same ratio of $\frac{f_{s2}}{f_{s1}}$ where $f_{s1}$ are the new and original sampling rates respectively.

To shift all frequencies by one Hz, you could take a Hilbert Transform of the waveform to get the Analytic Signal and then multiply the complex Analytic Signal by the complex exponential frequency $x[n]$ for a one Hz offset as given by:

$$x[n] = e^{j2 \pi f/f_s n} $$

Where $f$ is 1 Hz, $f_s$ is the sampling rate, and $n$ is the sample index. The real of this result would be the original waveform with all frequencies shifted by 1 Hz.

This approach is further outlined in this post.

The necessary Hilbert Transform can be easily implemented with the FFT as described in this post.

Answer 2

I found out that I need to calculate the wavelength of middle C in the sample. If the sample plays a Middle C of 261.63 hertz I can do this with the following formula. \begin{equation} w = p/f, \end{equation} Where w = wavelength of middle C in samples (261.63 in this example) p = play sample rate of middle C and f = middle c frequency (usually around 261.63 Hz)

Adding to or subtracting w from the play sample rate will detune it by 1Hz.

If I want to detune it by more or less than one hertz I can multiply w with the amount of hertz to detune the waveform by. \begin{equation} a = fw \end{equation} where f is detune frequency and a is detuning amount to add to/subtract from the play sample