std::out_of_range error

#include <Bela.h>
#include <libraries/Fft/Fft.h>
#include <libraries/Scope/Scope.h>
#include <libraries/Gui/Gui.h>
#include <libraries/GuiController/GuiController.h>
#include <cmath>
#include <cstring>
#include <vector>
#include <algorithm>
#include "MonoFilePlayer.h"

// FFT-related variables
Fft gFft;							// FFT processing object
const int gFftSize = 1024;			// FFT window size in samples
int gHopSize = 128;					// How often we calculate a window
float gScaleFactor = 0.25;			// How much to scale the output, based on window type and overlap
float gBaseFrequency = 110;			// Fundamental frequency of the robot effect
float gSampleRate = 44100;			// Sample rate (updated in setup())

// Circular buffer and pointer for assembling a window of samples
const int gBufferSize = 16384;
std::vector<float> gInputBuffer;
int gInputBufferPointer = 0;
int gHopCounter = 0;

// Circular buffer for collecting the output of the overlap-add process
std::vector<float> gOutputBuffer;

// Start the write pointer ahead of the read pointer by at least window + hop, with some margin
int gOutputBufferWritePointer = gFftSize + 2*gHopSize;
int gOutputBufferReadPointer = 0;

// Buffer to hold the windows for FFT analysis and synthesis
std::vector<float> gAnalysisWindowBuffer;
std::vector<float> gSynthesisWindowBuffer;

std::vector<float> gBinFrequencies(gFftSize/2 + 1);

// Name of the sound file (in project folder)
std::string gFilename = "Poem.wav"; 

// Object that handles playing sound from a buffer
MonoFilePlayer gPlayer;

// Thread for FFT processing
AuxiliaryTask gFftTask;
int gCachedInputBufferPointer = 0;

void process_fft_background(void *);

// Bela oscilloscope
Scope gScope;

// Browser-based GUI to adjust parameters
Gui gGui;
GuiController gGuiController;

int mode = 0;

// Analog inputs
float gPot1;
float gPot2;

// Digital inputs
int gButton = 1;
int gLastButtonStatus = HIGH;
std::vector<int> gNum = {0, 1};  // vector to cylce through that chooses the filter type
unsigned int gNumLocation = 0;      // pointer for vector

int gAudioFramesPerAnalogFrame = 0;

float potValue = 0;

// This function handles the FFT processing in this example once the buffer has
// been assembled.

void process_fft(std::vector<float> const& inBuffer, unsigned int inPointer, std::vector<float>& outBuffer, unsigned int outPointer, int mode, float potValue)
{
	static std::vector<float> unwrappedBuffer(gFftSize);	// Container to hold the unwrapped time-domain values
	
	static std::vector<float> lastInputPhases(gFftSize);	// Hold the phases from the previous hop of input signal
	static std::vector<float> lastOutputPhases(gFftSize);	// and output (synthesised) signal
	
	// These containers hold the converted representation from magnitude-phase
	// into magnitude-frequency, used for pitch shifting
	static std::vector<float> analysisMagnitudes(gFftSize / 2 + 1);
	static std::vector<float> analysisFrequencies(gFftSize / 2 + 1);
	static std::vector<float> synthesisMagnitudes(gFftSize / 2 + 1);
	static std::vector<float> synthesisFrequencies(gFftSize / 2 + 1);
	static std::vector<int> synthesisCount(gFftSize / 2 + 1);
	
	// Copy buffer into FFT input
	for(int n = 0; n < gFftSize; n++) {
		// Use modulo arithmetic to calculate the circular buffer index
		int circularBufferIndex = (inPointer + n - gFftSize + gBufferSize) % gBufferSize;
		unwrappedBuffer[n] = inBuffer[circularBufferIndex] * gAnalysisWindowBuffer[n];
	}
	
	// Process the FFT based on the time domain input
	gFft.fft(unwrappedBuffer);

Note that this function is too long to fit into a single message and so has been split into multiple parts
1/3

if(mode==0){
		gBaseFrequency = potValue;
		
		// Analyse the lower half of the spectrum. The upper half is just
		// the complex conjugate and does not contain any unique information
		for(int n = 0; n <= gFftSize/2; n++) {
			// Turn real and imaginary components into amplitude and phase
			float amplitude = gFft.fda(n);
			float phase = atan2f(gFft.fdi(n), gFft.fdr(n));
		
			// Calculate the phase difference in this bin between the last
			// hop and this one, which will indirectly give us the exact frequency
			float phaseDiff = phase - lastInputPhases[n];
		
			// Subtract the amount of phase increment we'd expect to see based
			// on the centre frequency of this bin (2*pi*n/gFftSize) for this
			// hop size, then wrap to the range -pi to pi
			phaseDiff = wrapPhase(phaseDiff - gBinFrequencies[n] * gHopSize);
		
			// Find deviation from the centre frequency
			float frequencyDeviation = phaseDiff / (float)gHopSize;
		
			// Add the original bin number to get the fractional bin where this partial belongs
			analysisFrequencies[n] = ((float)n * 2.0 * M_PI / (float)gFftSize) + frequencyDeviation;
		
			// Save the magnitude for later and for the GUI
			analysisMagnitudes[n] = amplitude;
		
			// Save the phase for next hop
			lastInputPhases[n] = phase;
		}	

		// Zero out the synthesis bins, ready for new data
		for(int n = 0; n <= gFftSize/2; n++) {
			synthesisMagnitudes[n] = synthesisFrequencies[n] = synthesisCount[n] = 0;
		}
	
		// Handle the robotisation effect, storing frequencies into new bins
		for(int n = 0; n <= gFftSize/2; n++) {
			// Round the frequency to the nearest multiple of the fundamental
			float harmonicRaw = analysisFrequencies[n]*gSampleRate/(2.0*M_PI)/gBaseFrequency;
			float harmonicBelow = floorf(harmonicRaw);
			float harmonicAbove = harmonicBelow + 1;
			float harmonicFraction = harmonicRaw - harmonicBelow;

			// Only resynthesise frequenices greater than 0
			if(harmonicBelow > 0) {
				float newFrequency = gBaseFrequency*(2.0*M_PI/gSampleRate)*harmonicBelow;
			
				// Find the nearest bin to the shifted frequency
				int newBin = floorf(newFrequency*(float)gFftSize/(2.0*M_PI) + 0.5);
			
				// Ignore any bins that have shifted above Nyquist
				if(newBin <= gFftSize/2) {
					synthesisMagnitudes[newBin] += analysisMagnitudes[n]*(1.0 - harmonicFraction);
					synthesisFrequencies[newBin] = newFrequency;
				}
			}
		
			// harmonicAbove is always > 0
			float newFrequency = gBaseFrequency*(2.0*M_PI/gSampleRate)*harmonicAbove;
		
			// Find the nearest bin to the shifted frequency
			int newBin = floorf(newFrequency*(float)gFftSize/(2.0*M_PI) + 0.5);
		
			// Ignore any bins that have shifted above Nyquist
			if(newBin <= gFftSize/2) {
				synthesisMagnitudes[newBin] += analysisMagnitudes[n]*harmonicFraction;
				synthesisFrequencies[newBin] = newFrequency;
			}
		}
		
		// Synthesise frequencies into new magnitude and phase values for FFT bins
		for(int n = 0; n <= gFftSize / 2; n++) {
			// Get the fractional offset from the bin centre frequency
			float frequencyDeviation = synthesisFrequencies[n] - ((float)n * 2.0 * M_PI / (float)gFftSize);
		
			// Multiply to get back to a phase value
			float phaseDiff = frequencyDeviation * (float)gHopSize;
		
			// Add the expected phase increment based on the bin centre frequency
			phaseDiff +=  gBinFrequencies[n] * gHopSize;
		
			// Advance the phase from the previous hop
			float outPhase = wrapPhase(lastOutputPhases[n] + phaseDiff);
		
			// Now convert magnitude and phase back to real and imaginary components
			gFft.fdr(n) = synthesisMagnitudes[n] * cosf_neon(outPhase);
			gFft.fdi(n) = synthesisMagnitudes[n] * sinf_neon(outPhase);
		
			// Also store the complex conjugate in the upper half of the spectrum
			if(n > 0 && n < gFftSize / 2) {
				gFft.fdr(gFftSize - n) = gFft.fdr(n);
				gFft.fdi(gFftSize - n) = -gFft.fdi(n);
			}
		
			// Save the phase for the next hop
			lastOutputPhases[n] = outPhase;
		}
	}

2/3