runtime::AudioBuffer & decoded,

const AceStepRepaintSpliceSource & source,

float crossfade_seconds) {

if (decoded.sample_rate != kAceStepAudioSampleRate || source.audio.sample_rate != kAceStepAudioSampleRate ||

decoded.channels != kAceStepAudioChannels || source.audio.channels != kAceStepAudioChannels) {

throw std::runtime_error("ACE-Step repaint waveform splice requires stereo 48 kHz audio");

}

const int64_t decoded_frames =

static_cast<int64_t>(decoded.samples.size() / static_cast<size_t>(decoded.channels));

const int64_t source_frames =

static_cast<int64_t>(source.audio.samples.size() / static_cast<size_t>(source.audio.channels));

const int64_t frames = std::min(decoded_frames, source_frames);

if (frames <= 0) {

throw std::runtime_error("ACE-Step repaint waveform splice requires non-empty audio");

}

int64_t start_frame =

static_cast<int64_t>(static_cast<double>(source.start_seconds) * static_cast<double>(kAceStepAudioSampleRate));

int64_t end_frame =

static_cast<int64_t>(static_cast<double>(source.end_seconds) * static_cast<double>(kAceStepAudioSampleRate));

start_frame = std::max<int64_t>(0, std::min<int64_t>(start_frame, frames));

end_frame = std::max<int64_t>(start_frame, std::min<int64_t>(end_frame, frames));

if (start_frame == 0 && end_frame >= frames) {

return;

}

const int64_t crossfade_frames =

static_cast<int64_t>(static_cast<double>(crossfade_seconds) * static_cast<double>(kAceStepAudioSampleRate));

const int64_t fade_start = std::max<int64_t>(0, start_frame - std::max<int64_t>(0, crossfade_frames));

const int64_t fade_end = std::min<int64_t>(frames, end_frame + std::max<int64_t>(0, crossfade_frames));

const int64_t left_ramp_len = start_frame - fade_start;

const int64_t right_ramp_len = fade_end - end_frame;

if (fade_start > 0) {

std::copy(

source.audio.samples.begin(),

source.audio.samples.begin() + static_cast<std::ptrdiff_t>(fade_start * kAceStepAudioChannels),

decoded.samples.begin());

}

for (int64_t frame = fade_start; frame < start_frame; ++frame) {

const float mask = static_cast<float>(frame - fade_start + 1) / static_cast<float>(left_ramp_len + 1);

const size_t base = static_cast<size_t>(frame * kAceStepAudioChannels);

for (int channel = 0; channel < kAceStepAudioChannels; ++channel) {

const size_t index = base + static_cast<size_t>(channel);

decoded.samples[index] =

mask * decoded.samples[index] + (1.0F - mask) * source.audio.samples[index];

}

}

for (int64_t frame = end_frame; frame < fade_end; ++frame) {

const float mask = 1.0F - static_cast<float>(frame - end_frame + 1) / static_cast<float>(right_ramp_len + 1);

const size_t base = static_cast<size_t>(frame * kAceStepAudioChannels);

for (int channel = 0; channel < kAceStepAudioChannels; ++channel) {

const size_t index = base + static_cast<size_t>(channel);

decoded.samples[index] =

mask * decoded.samples[index] + (1.0F - mask) * source.audio.samples[index];

}

}

if (fade_end < frames) {

const auto source_begin =

source.audio.samples.begin() + static_cast<std::ptrdiff_t>(fade_end * kAceStepAudioChannels);

const auto source_end =

source.audio.samples.begin() + static_cast<std::ptrdiff_t>(frames * kAceStepAudioChannels);

const auto decoded_begin =

decoded.samples.begin() + static_cast<std::ptrdiff_t>(fade_end * kAceStepAudioChannels);

std::copy(source_begin, source_end, decoded_begin);

}