What is the best workflow for gapless track switching?

[CptDoucheWizard]

Hi guys,
I'm working on a project to add audio to a WiFi controlled model. The intent is to switch between tracks to add realism to movement.
This is working well, however I am struggling to get a seamless transition between the end of one track and the beginning of the other. As an example, switching from engine start, to engine idle. Tracks are being stored in SPIFFs, are WAV, and roughly 30kB, 7 seconds long played over I2S with a MAX98357A

Initially it was set up to load in the relevant file every time I wanted to switch tracks, and then inputting the file into a copier.begin function. I then did a File.avaliable() to see if the track was finished, and then File.seek(0) if it had. This played fine, looped okay (still need to sort out the popping but I see there are plenty of tips on that front already), but like I said there was an obvious gap between one track and the next. Looping however, had no gap.
I assumed that the file load time was the cause of my gap and the approach seemed inefficient, so I decided to switch to loading all of the files in the setup, and then based on the state I would input the relevant file to copier.begin.
It seems I get the same duration gap inbetween tracks regardless of the approach, which makes me wonder if there is something behind the scenes that I am missing. Is there a buffer or something that I need to wipe, or do I need to shut down the copier somehow?

I could just put all the sounds I want into one long track, and then seek to the position of the sound I need, but that doesn't really seem like the most elegant solution. Perhaps I am meant to have a copier per file, and only enter the relevant copier.copy based on the device state?

I've done my best to glean information from the documentation but there is alot of assumed knowledge which I am lacking.
Thanks

#include "AudioTools/AudioLibs/AudioSourceSPIFFS.h"
#include "AudioTools/AudioCodecs/CodecWAV.h"
#include "FS.h"
#include "SPIFFS.h"

#define SOUND_GUN_FIRE "/cannon_120mm_Rh120_shot_01.wav"
#define SOUND_IDLE "/leo1_engine_rpm_00_load.wav"
#define SOUND_ENGINE_START "/leo1_engine_start.wav"

#define ENGINE_START_CASE 1
#define ENGINE_IDLE_CASE 2
#define GUN_FIRING_CASE 3

AudioInfo audioInfo(22050, 1, 16);

//AudioInfo audioInfo(SAMPLE_RATE, AUDIO_CHANNELS, BITS_PER_SAMPLE);
File engineStartFile;
File engineIdleFile;
File gunFiringFile;

File wavFile;

// data flow: wavFile -> decoder -> encoder -> volume -> fader -> i2s
//AudioSourceSPIFFS source(startFilePath, ext);
I2SStream i2s; // final output of stream
FadeStream fader(i2s);
VolumeStream volume(fader); // intermediate to set the volume
WAVDecoder decoder;
EncodedAudioOutput encoder(&volume, &decoder); // Decoding stream
StreamCopy copier;

int audioState = 0;

int leftFWD = A1;
int leftBWD = A0;
int rightFWD = A3;
int rightBWD = A2;

void setup()
{
  analogWrite(leftFWD, 0);
  analogWrite(leftBWD, 0);
  analogWrite(rightFWD, 0);
  analogWrite(rightBWD, 0);

  
  Serial.begin(115200);

  SPIFFS.begin();

  I2SConfig config = i2s.defaultConfig(TX_MODE);
  config.copyFrom(audioInfo);
  config.pin_bck = 6;
  config.pin_ws = 43;
  config.pin_data = 5;
  i2s.begin(config);

  fader.setAudioInfo(audioInfo);

  volume.begin(config); // we need to provide the bits_per_sample and channels

  float startingVolume = 0.5;
  volume.setVolume(startingVolume);

  encoder.begin(); // reset sound at beginning of data

  copier.begin(encoder, wavFile); // activate copier
  copier.setMinCopySize(1);       // allow partial frames

  gunFiringFile = SPIFFS.open(SOUND_GUN_FIRE,"r");
  engineIdleFile = SPIFFS.open(SOUND_IDLE,"r");
  engineStartFile = SPIFFS.open(SOUND_ENGINE_START,"r");


}

bool isRunning()
{
  return copier.isActive();
}

void loop()
{
    audioLoop();


    if (Serial.available() > 0) {
      String command = Serial.readString();
      Serial.println(command);

      Serial.println(String(command[0] - '0'));
      
      audioState = command[0] - '0';

      Serial.println("audiostate is now " + String(audioState));


    }
}

void audioLoop(){
  try{
          switch (audioState){
            case GUN_FIRING_CASE:
              copier.begin(encoder, gunFiringFile); // activate copier
              Serial.println("Begin gun firing, file size is " + String(gunFiringFile.size()) + " and is available " + String(gunFiringFile.available()));
              if(gunFiringFile.available() <= 0){
                audioState = ENGINE_IDLE_CASE;
                gunFiringFile.seek(0);
                Serial.println("Switching to idle");
              }
              break;
            case ENGINE_START_CASE:
              copier.begin(encoder, engineStartFile); // activate copier
              Serial.println("Begin engine start");
              if(engineStartFile.available() <= 0){
                audioState = ENGINE_IDLE_CASE;
                engineStartFile.seek(0);
                Serial.println("Switching to idle");
              }
              break;
            case ENGINE_IDLE_CASE:
              copier.begin(encoder, engineIdleFile); // activate copier
              Serial.println("Begin engine idle");
              if(engineIdleFile.available() <= 0){
                engineIdleFile.seek(0);
                Serial.println("Staying on idle");
              }
              break;
          }
          int size = copier.copy();
          //Serial.println("File available, and playing");
          // there is a bug where sounds sometimes don't complete,
          // this code is a workaround to force completion
        /*  if (size == 0)
          {
              ESP_LOGW(MODULE_NAME_SOUND, "copier.copy() %d %d %d %d", size, wavFile.available(), wavFile.position(), wavFile.size());

              wavFile.close();
          }*/
      }
      catch (const std::exception &e)
      {
          // don't allow an exception here to crash the system
          ESP_LOGE(MODULE_NAME_SOUND, "%s", e.what());
      }
}

[pschatzmann]

Did you check if there is some silence in your files at the end or beginning.
The other issue is that you do not reopen the processing when you start a new file. Wav files start with a header and if the decoder is not in starting state the header is treated as audio data: this will lead to some undefined noise.