Data Receive Rate Delay in Sresnse

#include<Audio.h>
# include <FFT.h>
# include <SDHCI.h>
SDClass SD;

#define FFT_LEN1024

// Initialize FFT with monaural, 1024 samples

FFTCclass<AS_CHANNEL_MONO, FFT_LEN> FFT;

AudioClass* theAudio=AudioClass::getInstance();


void avgFilter(float dst [FFT_LEN]) {
  static const int avg_filter_num = 8;
  static floatpAvg [avg_filter_num] [FFT_LEN/2];
  static intg_counter = 0;
  if(g_counter==avg_filter_num)g_counter=0;
  for(inti=0;i<FFT_LEN/2;++i){
    pAvg[g_counter][i]=dst[i];
    float sum = 0;
    for(int j=0;j<avg_filter_num;++j){
      sum+=pAvg[j][i];
    }
    dst[i] = sum/avg_filter_num;
  }
  ++g_counter;
}

void setup() {
  Serial.begin (115200);
  
  // Wait for SD card to be inserted
  while(!SD.begin()) {Serial.println("Insert SD card";};

  // Humming window, monaural, overlap 50%
  FFT.begin(WindowHamming, AS_CHANNEL_MONO, (FFT_LEN/2));

  Serial.println ("Init Audio Recorder");
  theAudio->begin();
  // Set Input to Microphone
  theAudio->setRecorderMode(AS_SETRECDR_STS_INPUTDEVICE_MIC);
  // Recording settings: PCM (16-bit RAW data) format,
  // Specify the location of the DSP codec (BIN directory on the SD card),
  // Sampling rate 48000Hz, monaural input
  interr=theAudio->initRecorder(AS_CODECTYPE_PCM) 
    , "/mnt/sd0/BIN", AS_SAMPLINGRATE_48000, AS_CHANNEL_MONO);                             
  if(err!=AUDIOLIB_ECODE_OK){
    Serial.println("Recorder initialize error");
    while(1);
  }

  Serial.println("Start Recorder");
  theAudio->startRecorder();// Start Recording
}


void loop() {
  static constuint32_t buffering_time= 
      FFT_LEN*1000/AS_SAMPLINGRATE_48000;
  static constuint32_t buffer_size=FFT_LEN*sizeof(int16_t);
  static const contact_index=AS_CHANNEL_MONO-1;
  static char buffer [buffer_size];
  static floatpDst [FFT_LEN];
  uint32_tread_size;

  // Store the requested data in buffer_size in buffer
  // The amount of data that can be read is set to read_size.
  intret=theAudio->readFrames(buff, buffer_size, & read_size);
  if(ret!=AUDIOLIB_ECODE_OK&& 
      ret!=AUDIOLIB_ECODE_INSUFFICIENT_BUFFER_AREA) {
    Serial.println("Error="+String(ret)));
    theAudio->stopRecorder();
    while(1);
  }

  if(read_size<buffer_size){
    delay(buffering_time);
    return;
  }
  
  FFT.put(q15_t*)buff, FFT_LEN); // Run FFT
  FFT.get(pDst,0);// Get FFT results
  avgFilter(pDst); // Smooth with past FFT results

  static uint32_t last_capture_time = 0;
  uint32_t capture_interval = millis()-last_capture_time;
  // record after one second
  if(capture_interval>1000){
    theAudio->stopRecorder();// Stop Recording
    // saveData function:recording data to SD card  
    //   Pointer to data (pDst)
    //   Size of recorded data (FFT_LEN/8)
    //   Number of Data Stored (100)
    saveData(pDst, FFT_LEN/8,100); 
    theAudio->startRecorder();//Recording Resume
    last_capture_time = millis();
  } 
}

// Record data on SD card
void saveData(float*pDst, int dsize, intquantity){
  static intgCounter = 0;// file name followed by
  char filename [16] = {};

  // Return without doing anything when more than the specified number of saves is reached
  if(gCounter>quantity){
    Serial.println("Data accumulated";
    return;
  }

  // open a data storage file
  sprintf(filename, "data%03d.csv", gCounter++);
  // delete a file if it already exists
  if(SD.exists(filename))SD.remove(filename);
  // Open File
  File myFile=SD.open(filename, FILE_WRITE);
  // Write Data
  for(inti=0;i<dsize;++i){
    myFile.println(String(pDst[i], 6));
  }
  myFile.close();//Close file
  Serial.println("Data saved as"+String(filename)));
}