108 lines
5.0 KiB
C++
108 lines
5.0 KiB
C++
// See bake_plan.h.
|
|
|
|
#include "core/instrument/bake/bake_plan.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
|
|
#include "core/instrument/map/trigger_seam.h" // triggerPlayLength (the one span formula)
|
|
|
|
namespace reasampler::instrument::bake {
|
|
|
|
using note::NoteProgram;
|
|
using note::ResolvedNote;
|
|
|
|
namespace {
|
|
|
|
// Seconds -> frames by round-half-away-from-zero, the one conversion every field here uses,
|
|
// so the window and its event frames cannot round against each other. Reports failure
|
|
// rather than clamping: the double->int64 narrowing below is undefined once the product
|
|
// leaves int64's range, which a legal offset magnitude reaches long before that.
|
|
bool toFrames(double seconds, int rate, std::int64_t& out) {
|
|
const double frames = seconds * static_cast<double>(rate);
|
|
const auto ceiling = static_cast<double>(kMaxBakeFrames);
|
|
if (!(frames >= -ceiling && frames <= ceiling)) return false; // also catches NaN
|
|
out = static_cast<std::int64_t>(std::llround(frames));
|
|
return true;
|
|
}
|
|
|
|
// The deepest DOWNWARD pitch offset the dialed voice can reach, in semitones (<= 0). Only
|
|
// Varispeed needs it: there the read head advances at the pitch ratio, so a downward offset
|
|
// stretches how long Trigger's source span takes to play. Preserve decouples the two, and a
|
|
// Gate release is ticked per output frame, so neither is affected.
|
|
double downwardSemitones(const PlayParams& play, int velocity) {
|
|
if (play.pitchEngine != PitchEngine::Varispeed) return 0.0;
|
|
double down = (std::min)(0.0, kVelocityPitchRangeSemitones *
|
|
play.pitchVelocityCurve.eval(velocity));
|
|
if (play.pitchEnv.enabled) {
|
|
// A drawn contour is bipolar, so it reaches -|peak| whichever way the depth points;
|
|
// the staged AHD only ever travels between 0 and the peak.
|
|
down += play.pitchSpline.mode == EnvMode::Spline
|
|
? -std::fabs(play.pitchEnv.peakSemitones)
|
|
: (std::min)(0.0, play.pitchEnv.peakSemitones);
|
|
}
|
|
return down;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
NoteProgram defaultBakeProgram(const SampleData& dialed, int renderSampleRate,
|
|
note::Tempo tempo) {
|
|
NoteProgram p; // 1/4 straight, velocity 100, capture opening at note-on
|
|
if (renderSampleRate <= 0) return p;
|
|
const double rate = static_cast<double>(renderSampleRate);
|
|
|
|
double endOffsetSeconds = 0.0;
|
|
if (dialed.play.playMode == PlayMode::Trigger) {
|
|
// Trigger ignores note-off entirely: the sound ends when the read head reaches the
|
|
// play span's end, which has nothing to do with the note's length — so the end
|
|
// offset is whatever is left after the note, positive or negative.
|
|
const std::int64_t span = map::triggerPlayLength(
|
|
dialed.play.trigger.lengthFraction,
|
|
static_cast<std::int64_t>(dialed.frames.size()), dialed.startFrame);
|
|
const double stretch = std::pow(
|
|
2.0, -downwardSemitones(dialed.play, p.velocity.value()) / 12.0);
|
|
endOffsetSeconds = static_cast<double>(span) / rate * stretch -
|
|
tempo.beatsToSeconds(note::divisionBeats(p.length));
|
|
} else {
|
|
// Gate: the release is the one stage that runs after note-off, so it is exactly
|
|
// what the window has to hold past it.
|
|
endOffsetSeconds = static_cast<double>(dialed.play.adsr.releaseFrames) / rate;
|
|
}
|
|
p.end = note::EndOffset(note::offsetFromMs(endOffsetSeconds * 1000.0));
|
|
return p;
|
|
}
|
|
|
|
std::optional<BakePlan> planBake(const ResolvedNote& resolved, int sampleRate,
|
|
int rootNote) {
|
|
if (resolved.windowCollapsed) return std::nullopt;
|
|
if (sampleRate <= 0) return std::nullopt;
|
|
|
|
// The render starts at whichever comes first, note-on or the capture opening. A POSITIVE
|
|
// start offset is legal and means the capture opens after the note — so the head is
|
|
// rendered and discarded, never folded away by sliding note-on later inside the window.
|
|
const double renderStartSeconds = (std::min)(resolved.captureStartSeconds, 0.0);
|
|
|
|
BakePlan plan;
|
|
plan.sampleRate = sampleRate;
|
|
if (!toFrames(resolved.captureLengthSeconds(), sampleRate, plan.totalFrames))
|
|
return std::nullopt;
|
|
if (plan.totalFrames <= 0) return std::nullopt;
|
|
if (!toFrames(resolved.captureStartSeconds - renderStartSeconds, sampleRate,
|
|
plan.leadInFrames))
|
|
return std::nullopt;
|
|
if (!toFrames(-renderStartSeconds, sampleRate, plan.noteOnFrame)) return std::nullopt;
|
|
if (!toFrames(resolved.noteOffSeconds - renderStartSeconds, sampleRate,
|
|
plan.noteOffFrame))
|
|
return std::nullopt;
|
|
// Each field cleared the ceiling alone; the render holds their sum.
|
|
if (plan.renderFrames() > kMaxBakeFrames) return std::nullopt;
|
|
|
|
plan.noteOffFrame = (std::max)(plan.noteOffFrame, plan.noteOnFrame);
|
|
plan.note = std::clamp(rootNote, 0, 127);
|
|
plan.velocity = std::clamp(static_cast<int>(resolved.velocity), 1, 127);
|
|
return plan;
|
|
}
|
|
|
|
} // namespace reasampler::instrument::bake
|