Fmod, одновременное воспроизведение звуков и запись их в файл

FMOD_CREATESOUNDEXINFO exinfo = {};

exinfo.cbsize = sizeof(FMOD_CREATESOUNDEXINFO);
exinfo.length = size;

result = data.fmod->system->createSound(buf, FMOD_3D | FMOD_OPENMEMORY, &exinfo, &sound.m_sound); 

FMOD_RESULT F_CALLBACK myDSPCallback(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels)
{
  mydsp_data_t *data = (mydsp_data_t *)dsp_state->plugindata;

  for (unsigned int samp = 0; samp < length; samp++)
  {
    for (int chan = 0; chan < *outchannels; chan++)
    {
      data->buffer[(samp * *outchannels) + chan] = outbuffer[(samp * inchannels) + chan] = inbuffer[(samp * inchannels) + chan];
    }
  }
  data->channels = inchannels;
  return FMOD_OK;
}

std::vector<short> Sound_Buffer; // это буфер куда накапливается звук.
// инициализация
FMOD_RESULT Sound::SetRecorder()
{
  FMOD_DSP_DESCRIPTION dspdesc;
  memset(&dspdesc, 0, sizeof(dspdesc));

  strncpy(dspdesc.name, "DSP unit", sizeof(dspdesc.name));
  dspdesc.version = 0x00010000;
  dspdesc.numinputbuffers = 1;
  dspdesc.numoutputbuffers = 1;
  dspdesc.read = myDSPCallback;
  dspdesc.create = myDSPCreateCallback;
  dspdesc.release = myDSPReleaseCallback;

  FMOD_RESULT result = system->createDSP(&dspdesc, &mydsp);
  if (result != FMOD_OK)
    return result;

  result = system->getMasterChannelGroup(&mastergroup);
  if (result != FMOD_OK)
    return result;

  return mastergroup->addDSP(0, mydsp);
}
/*
  Callback called when DSP is created.
*/
#include <chrono>
std::chrono::high_resolution_clock::time_point start_time;
FMOD_RESULT F_CALLBACK myDSPCreateCallback(FMOD_DSP_STATE *dsp_state)
{
  unsigned int blocksize;
  FMOD_RESULT result;

  result = dsp_state->functions->getblocksize(dsp_state, &blocksize);
  if (result != FMOD_OK)
    return result;

  mydsp_data_t *data = (mydsp_data_t *)calloc(sizeof(mydsp_data_t), 1);
  if (!data)
  {
    return FMOD_ERR_MEMORY;
  }
  dsp_state->plugindata = data;
  data->length_samples = blocksize;

  data->buffer = (float *)malloc(blocksize * 2 * sizeof(float)); // 2 channels (stereo).
  if (!data->buffer)
  {
    return FMOD_ERR_MEMORY;
  }
  start_time = std::chrono::high_resolution_clock::now();
  return FMOD_OK;
}
// Основной колбек. Тут накапливается звук.
FMOD_RESULT F_CALLBACK myDSPCallback(FMOD_DSP_STATE *dsp_state, float *inbuffer, float *outbuffer, unsigned int length, int inchannels, int *outchannels)
{
  mydsp_data_t *data = (mydsp_data_t *)dsp_state->plugindata;

  for (unsigned int samp = 0; samp < length; samp++)
  {
    for (int chan = 0; chan < *outchannels; chan++)
    {
      short val = inbuffer[(samp * inchannels) + chan] * 32768.0;
      Sound_Buffer.push_back(val);  // просто добавляю данные к буферу преобразовывая float в short 
    }
  }
  data->channels = inchannels;

  return FMOD_OK;
}

// А это вызывается в конце и записывает все на диск
#include <fstream>
void write32(ofstream &stream, int value)
{
  stream.write((const char*)&value, sizeof value);
}
void write16(ofstream &stream, short value)
{
  stream.write((const char*)&value, sizeof value);
}
FMOD_RESULT F_CALLBACK myDSPReleaseCallback(FMOD_DSP_STATE *dsp_state)
{
  if (dsp_state->plugindata)
  {
    if (Sound_Buffer.size())
    {
      std::chrono::milliseconds duration = std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now() - start_time);

      ofstream stream;
      int samplerate = Sound_Buffer.size() / (duration.count()*2.0 / 1000.0);    //44100;
      int frame_size = sizeof(Sound_Buffer[0]);
      stream.open("output.wav", ios::out | ios::binary);

      stream.write("RIFF", 4);  // RIFF chunk
      write32(stream, 36 + Sound_Buffer.size() * frame_size);  // RIFF chunk size in bytes
      stream.write("WAVE", 4); // WAVE chunk
      stream.write("fmt ", 4); // fmt chunk
      write32(stream, 16);     // size of fmt chunk
      write16(stream, 1);       // Format = PCM
      write16(stream, 2);       // # of Channels
      write32(stream, samplerate); // Sample Rate
      write32(stream, samplerate * frame_size); // Byte rate
      write16(stream, frame_size); // Frame size
      write16(stream, 16); // Bits per sample
      stream.write("data", 4); // data chunk
      write32(stream, Sound_Buffer.size() * frame_size); // data chunk size in bytes

      for (int i = 0; i < Sound_Buffer.size(); i++)
        write16(stream, Sound_Buffer[i]);
    }

    mydsp_data_t *data = (mydsp_data_t *)dsp_state->plugindata;
    if (data->buffer)
    {
      free(data->buffer);
    }
    free(data);
  }
  return FMOD_OK;
}