function mcleodPitchMethod(signal, samplerate) {
    // 1. Calculate the normalized squared difference function (NSDF).
    // NSDF is a measure of how similar a waveform is to a time-shifted version of itself.
    
    let nsdf = new Float32Array(signal.length); // Array to store NSDF values.
    for (let tau = 0; tau < signal.length; tau++) {
        // 'tau' is the amount of time-shift.
        let m = 0.0; // Accumulator for the numerator of the NSDF formula.
        let n1 = 0.0; // Part of the denominator.
        let n2 = 0.0; // Another part of the denominator.
        
        for (let j = 0; j < signal.length - tau; j++) {
            // Calculate the values used in the NSDF formula.
            m += signal[j] * signal[j + tau];
            n1 += signal[j] * signal[j];
            n2 += signal[j + tau] * signal[j + tau];
        }
        
        // Calculate the NSDF value for this value of 'tau'.
        nsdf[tau] = 2.0 * m / (n1 + n2);
    }

    // 2. Find local maxima in the NSDF array.
    // These are potential candidates for the detected pitch period.
    let maxPositions = []; // Array to store positions of local maxima.
    for (let i = 1; i < nsdf.length - 1; i++) {
        // Check if the current value is greater than its neighbors.
        if (nsdf[i] > nsdf[i - 1] && nsdf[i] > nsdf[i + 1]) {
            maxPositions.push(i);
        }
    }

    // 3. Choose the highest peak as the pitch period.
    // The highest peak corresponds to the best match for the pitch period.
    let highestPeakPos = maxPositions[0];
    for (let i = 1; i < maxPositions.length; i++) {
        if (nsdf[maxPositions[i]] > nsdf[highestPeakPos]) {
            highestPeakPos = maxPositions[i];
        }
    }

    // Convert the pitch period (in samples) to frequency (in Hz).
    // 'sampleRate' is the number of samples processed per second.     
    let pitchFrequency = sampleRate / highestPeakPos;

    return pitchFrequency;
}

// Function to calculate the Root Mean Square (RMS) of a set of audio
// samples. RMS provides a measure of the magnitude (or volume) of an
// audio signal.
function calculateRMS(samples) {
  // Initialize the sum of squares of each sample.
  let sumOfSquares = 0;

  // Loop through each sample in the audio buffer.
  for (let i = 0; i < samples.length; i++) {
    // Square each sample value and add it to the sum.
    sumOfSquares += samples[i] * samples[i];
  }

  // Calculate the mean (average) of the squared samples.
  // Then, take the square root of that mean to get the RMS value.
  let rms = Math.sqrt(sumOfSquares / samples.length);

  // Return the RMS value.
  return rms;
}

const PITCH_VOLUME_THRESHOLD = 0.03; // This is an arbitrary number; adjust based on testing and requirements.

// Create a new audio context. This is the primary object used in the Web Audio API.
let audioContext = new (window.AudioContext || window.webkitAudioContext)();

// Create a script processor node with a buffer size of 4096 samples.
// This node lets us directly process raw audio data using JavaScript.
// params are: buffer size, input channels, output channels.
let processor = audioContext.createScriptProcessor(4096, 1, 1);
let sampleRate = audioContext.sampleRate;

// Request access to the user's microphone.
navigator.mediaDevices
  .getUserMedia({ audio: true })
  .then((stream) => {
    // If access is granted, create a media stream source from the microphone stream.
    let source = audioContext.createMediaStreamSource(stream);

    // Connect the media source to the script processor node.
    // This means that audio from the mic will flow into our custom processing node.
    source.connect(processor);

    // Also, connect the script processor to the audio context's destination.
    // This ensures the audio plays back, so you can hear it (optional, based on use case).
    processor.connect(audioContext.destination);

    // This event fires whenever our buffer (of 4096 samples in this case) is full.
    processor.onaudioprocess = function (event) {
      // Get the audio samples from the input buffer.
      let inputBuffer = event.inputBuffer;

      // We're assuming mono sound, so only one channel.
      let inputData = inputBuffer.getChannelData(0);

      // Calculate the volume (RMS) of the current buffer.
      let rms = calculateRMS(inputData);

      // Check if the volume exceeds the threshold.
      if (rms > PITCH_VOLUME_THRESHOLD) {
        // If the volume is above the threshold, we process the data to detect pitch.
        let pitch = mcleodPitchMethod(inputData, sampleRate);
        console.log("Pitch:", pitch);
      } else {
        // If the volume is too low, skip processing and log a message.
        console.log("Volume too low. Skipping processing.");
      }
    };
  })
  .catch((err) => {
    // Handle any errors that occur when trying to access the microphone.
    console.error("Error accessing the microphone", err);
  });