daniel
65f6070348
Hold keeps its picker. Also: one home for the %-fold, duration-ordered Hold travel, and a corrupt tail degrades to absent rather than fabricating one.
328 lines
16 KiB
C++
328 lines
16 KiB
C++
// Standalone tests for reasampler::instrument::bake::bake_plan — no VST3, no REAPER, no
|
|
// framework. Same fast assert loop as the sibling pure tests.
|
|
//
|
|
// Covers: the default program's window derived from the dialed sound (Gate's hold to source
|
|
// exhaustion plus its release, a start point, a Trigger play span, and the Varispeed
|
|
// read-stretch bound on both branches that take it);
|
|
// the frame window and both event frames against hand-computed values; a capture opening
|
|
// BEFORE note-on and one opening AFTER it; the refusals and what each one reports — a
|
|
// collapsed window, a non-positive rate, a window that rounds to nothing, and one past the
|
|
// frame ceiling; and root/velocity clamping.
|
|
|
|
#include "../src/core/instrument/bake/bake_plan.h"
|
|
#include "../src/core/instrument/engine/voice.h" // kDeclickFrames (the window's tail pad)
|
|
|
|
#include <cstdio>
|
|
|
|
using namespace reasampler;
|
|
using namespace reasampler::instrument::bake;
|
|
using namespace reasampler::instrument::note;
|
|
|
|
static int g_fail = 0;
|
|
#define CHECK(cond) do { if(!(cond)) { \
|
|
std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)
|
|
|
|
static Tempo at(double bpm) {
|
|
const std::optional<Tempo> t = Tempo::fromBpm(bpm);
|
|
if (!t) { std::printf("FAIL: fixture tempo %f rejected\n", bpm); ++g_fail; }
|
|
return t.value_or(Tempo::fromBpm(120.0).value());
|
|
}
|
|
|
|
namespace {
|
|
|
|
constexpr int kRate = 48000;
|
|
|
|
// Every derived window carries the voice's terminal declick ramp as trailing silence.
|
|
const double kPadSeconds = static_cast<double>(kDeclickFrames) / kRate;
|
|
|
|
SampleData dialedSample(std::size_t frames = 96000) {
|
|
SampleData s;
|
|
s.frames.assign(frames, 0.5f);
|
|
s.sampleRate = kRate;
|
|
s.rootNote = 60;
|
|
return s;
|
|
}
|
|
|
|
// The Hold default; read only where the window is underivable, which is nowhere in this file.
|
|
Division oneBar() { return makeDivision(2, DivisionModifier::Straight); }
|
|
|
|
// `t` is unused by the derivation itself — it takes no tempo — but every caller here resolves
|
|
// against the same one, so threading it keeps each case's two halves visibly paired.
|
|
NoteProgram derived(const SampleData& s, Tempo) {
|
|
return defaultBakeProgram(s, kRate, oneBar(), Velocity{});
|
|
}
|
|
|
|
bool near(double a, double b) { return a > b - 1e-6 && a < b + 1e-6; }
|
|
|
|
} // namespace
|
|
|
|
int main() {
|
|
// --- Gate with no loop: held to source exhaustion, then the DIALED release ----------
|
|
{
|
|
SampleData s = dialedSample(); // 2 s of source == 4 beats
|
|
s.play.playMode = PlayMode::Gate;
|
|
s.play.adsr.releaseFrames = kRate * 3 / 2; // 1.5 s — past any fixed tail
|
|
const ResolvedNote r = resolveNote(derived(s, at(120.0)), at(120.0));
|
|
// The note is held to exhaustion — 2 s exactly — instead of the constant quarter note
|
|
// that released it early.
|
|
CHECK(near(r.noteOffSeconds, 2.0));
|
|
CHECK(r.captureStartSeconds == 0.0);
|
|
CHECK(near(r.captureEndSeconds, 2.0 + 1.5 + kPadSeconds));
|
|
CHECK(!r.windowCollapsed);
|
|
|
|
// A shorter release yields a shorter window — the derivation really reads the knob.
|
|
s.play.adsr.releaseFrames = kRate / 10; // 0.1 s
|
|
const ResolvedNote shorter = resolveNote(derived(s, at(120.0)), at(120.0));
|
|
CHECK(near(shorter.captureEndSeconds, 2.0 + 0.1 + kPadSeconds));
|
|
|
|
// The length is EXACT, not rounded onto the ladder: 2.5 s is 5 beats, which no rung
|
|
// hits — the ladder's nearest never-short answer is the 2/1 triplet at 5.33 beats, and
|
|
// taking it would buy a third of a second of silence for nothing. The tempo is not an
|
|
// input to a derived length at all, so the same sound derives the same seconds at any.
|
|
SampleData odd = dialedSample(static_cast<std::size_t>(kRate * 5 / 2)); // 2.5 s
|
|
odd.play.playMode = PlayMode::Gate;
|
|
CHECK(near(resolveNote(derived(odd, at(120.0)), at(120.0)).noteOffSeconds, 2.5));
|
|
CHECK(near(resolveNote(derived(odd, at(97.0)), at(97.0)).noteOffSeconds, 2.5));
|
|
}
|
|
|
|
// --- Gate with no loop, a START POINT set: only the post-start span is held ----------
|
|
// effectiveStart's whole reason to exist. A start marker means the head begins there, so
|
|
// holding the note for the WHOLE source would pad the window with silence the voice
|
|
// already finished; holding it for the source minus the start is exact.
|
|
{
|
|
SampleData s = dialedSample(/*frames=*/kRate * 2); // 2 s
|
|
s.play.playMode = PlayMode::Gate;
|
|
s.play.adsr.releaseFrames = 0;
|
|
s.startFrame = kRate / 2; // start half a second in -> 1.5 s of sound left
|
|
CHECK(near(resolveNote(derived(s, at(120.0)), at(120.0)).noteOffSeconds, 1.5));
|
|
|
|
// Voice::start's own degenerate rule: a start at or past the end plays from the top,
|
|
// so the window covers the whole source rather than nothing.
|
|
s.startFrame = kRate * 2;
|
|
CHECK(near(resolveNote(derived(s, at(120.0)), at(120.0)).noteOffSeconds, 2.0));
|
|
s.startFrame = -1;
|
|
CHECK(near(resolveNote(derived(s, at(120.0)), at(120.0)).noteOffSeconds, 2.0));
|
|
}
|
|
|
|
// --- Gate with no loop under Varispeed: the read-stretch bound applies here too -------
|
|
// The Trigger branch has its own coverage below; this pins that the Gate exhaustion length
|
|
// takes the same bound, which is the branch a downward offset would otherwise truncate.
|
|
{
|
|
SampleData s = dialedSample(/*frames=*/kRate); // 1 s
|
|
s.play.playMode = PlayMode::Gate;
|
|
s.play.adsr.releaseFrames = 0;
|
|
s.play.pitchEngine = PitchEngine::Varispeed;
|
|
s.play.pitchEnv.enabled = true;
|
|
s.play.pitchEnv.peakSemitones = -12.0; // an octave down == half speed at the peak
|
|
CHECK(near(resolveNote(derived(s, at(120.0)), at(120.0)).noteOffSeconds, 2.0));
|
|
|
|
// Preserve reads at the source rate, so the same dial bounds nothing.
|
|
s.play.pitchEngine = PitchEngine::Preserve;
|
|
CHECK(near(resolveNote(derived(s, at(120.0)), at(120.0)).noteOffSeconds, 1.0));
|
|
}
|
|
|
|
// --- Trigger: the window is the play span, which ignores the note's length ----------
|
|
{
|
|
SampleData s = dialedSample(/*frames=*/kRate * 2); // 2 s of source
|
|
s.play.playMode = PlayMode::Trigger;
|
|
s.play.trigger.lengthFraction = 0.75; // 1.5 s of it
|
|
const ResolvedNote r = resolveNote(derived(s, at(120.0)), at(120.0));
|
|
CHECK(r.captureStartSeconds == 0.0);
|
|
CHECK(near(r.captureEndSeconds, 1.5 + kPadSeconds));
|
|
|
|
// A shorter %-length is a shorter window, with no floor under it: the sound is over
|
|
// when the span is, and note-off means nothing to a Trigger voice.
|
|
s.play.trigger.lengthFraction = 0.1; // 0.2 s
|
|
const ResolvedNote brief = resolveNote(derived(s, at(120.0)), at(120.0));
|
|
CHECK(!brief.windowCollapsed);
|
|
CHECK(near(brief.captureEndSeconds, 0.2 + kPadSeconds));
|
|
}
|
|
|
|
// --- Trigger under Varispeed: a downward pitch offset stretches the read -----------
|
|
{
|
|
SampleData s = dialedSample(/*frames=*/kRate); // 1 s, played whole
|
|
s.play.playMode = PlayMode::Trigger;
|
|
s.play.pitchEngine = PitchEngine::Varispeed;
|
|
s.play.pitchEnv.enabled = true;
|
|
s.play.pitchEnv.peakSemitones = -12.0; // an octave down = half speed at the peak
|
|
const ResolvedNote r = resolveNote(derived(s, at(120.0)), at(120.0));
|
|
// Bounded at the deepest offset: 1 s of source can take up to 2 s to cross.
|
|
CHECK(near(r.captureEndSeconds, 2.0 + kPadSeconds));
|
|
|
|
// Preserve decouples pitch from the read rate, so the same dial bounds nothing.
|
|
s.play.pitchEngine = PitchEngine::Preserve;
|
|
const ResolvedNote kept = resolveNote(derived(s, at(120.0)), at(120.0));
|
|
CHECK(near(kept.captureEndSeconds, 1.0 + kPadSeconds));
|
|
}
|
|
|
|
// --- The bake fires at the velocity it is handed, and the Varispeed bound reads it ---
|
|
{
|
|
SampleData s = dialedSample(/*frames=*/kRate);
|
|
s.play.playMode = PlayMode::Trigger;
|
|
s.play.pitchEngine = PitchEngine::Varispeed;
|
|
// A bipolar velocity->pitch curve pulling a full octave down at velocity 0 and
|
|
// nothing at 127: the two velocities must therefore derive different windows.
|
|
s.play.pitchVelocityCurve = VelocityCurve::fromPoints(
|
|
{{0.0, -0.5}, {127.0, 0.0}}, reasampler::instrument::engine::CurveDomain::Bipolar);
|
|
|
|
const NoteProgram soft =
|
|
defaultBakeProgram(s, kRate, oneBar(), Velocity::of(1));
|
|
const NoteProgram hard =
|
|
defaultBakeProgram(s, kRate, oneBar(), Velocity::of(127));
|
|
CHECK(soft.velocity.value() == 1);
|
|
CHECK(hard.velocity.value() == 127);
|
|
const ResolvedNote softR = resolveNote(soft, at(120.0));
|
|
const ResolvedNote hardR = resolveNote(hard, at(120.0));
|
|
CHECK(near(hardR.captureEndSeconds, 1.0 + kPadSeconds)); // no offset at 127
|
|
CHECK(softR.captureEndSeconds > hardR.captureEndSeconds * 1.9); // ~an octave down
|
|
// …and the velocity reaches the plan, which is what the render fires.
|
|
CHECK(planBake(softR, kRate, 60).plan->velocity == 1);
|
|
}
|
|
|
|
// --- Gate with an ACTIVE sustain loop is the one case that needs Hold ---------------
|
|
{
|
|
SampleData s = dialedSample(/*frames=*/kRate);
|
|
s.play.playMode = PlayMode::Gate;
|
|
s.loop = SampleLoop{true, 0, kRate / 2};
|
|
CHECK(bakeWindowNeedsHold(s));
|
|
// The window follows Hold rather than the source, so a longer Hold is a longer file.
|
|
const ResolvedNote bar = resolveNote(
|
|
defaultBakeProgram(s, kRate, oneBar(), Velocity{}), at(120.0));
|
|
const ResolvedNote twoBars = resolveNote(
|
|
defaultBakeProgram(s, kRate,
|
|
makeDivision(3, DivisionModifier::Straight), Velocity{}),
|
|
at(120.0));
|
|
CHECK(near(bar.noteOffSeconds, 2.0));
|
|
CHECK(near(twoBars.noteOffSeconds, 4.0));
|
|
CHECK(near(twoBars.captureEndSeconds - bar.captureEndSeconds, 2.0));
|
|
}
|
|
|
|
// --- The frame window and both event frames ----------------------------------
|
|
{
|
|
NoteProgram p; // 1/4 straight, velocity 100
|
|
p.end = EndOffset(offsetFromMs(250.0));
|
|
const ResolvedNote r = resolveNote(p, at(120.0)); // note-off 0.5 s, end 0.75 s
|
|
const auto plan = planBake(r, 48000, 60).plan;
|
|
CHECK(plan.has_value());
|
|
CHECK(plan->totalFrames == 36000); // 0.75 s * 48 kHz
|
|
CHECK(plan->leadInFrames == 0);
|
|
CHECK(plan->renderFrames() == 36000);
|
|
CHECK(plan->noteOnFrame == 0);
|
|
CHECK(plan->noteOffFrame == 24000); // 0.5 s * 48 kHz
|
|
CHECK(plan->sampleRate == 48000);
|
|
CHECK(plan->note == 60);
|
|
CHECK(plan->velocity == 100);
|
|
}
|
|
|
|
// --- A capture that opens BEFORE note-on -------------------------------------
|
|
{
|
|
NoteProgram p;
|
|
p.start = StartOffset(offsetFromMs(-100.0)); // negative = earlier
|
|
p.end = EndOffset(offsetFromMs(100.0));
|
|
const ResolvedNote r = resolveNote(p, at(120.0));
|
|
const auto plan = planBake(r, 44100, 60).plan;
|
|
CHECK(plan.has_value());
|
|
// Window is [-0.1, 0.6] s = 0.7 s; note-on sits 0.1 s in, note-off 0.5 s after it.
|
|
CHECK(plan->totalFrames == 30870);
|
|
CHECK(plan->leadInFrames == 0); // nothing to discard: the file opens first
|
|
CHECK(plan->noteOnFrame == 4410);
|
|
CHECK(plan->noteOffFrame == 26460);
|
|
CHECK(plan->noteOffFrame - plan->noteOnFrame == 22050); // the note's own length
|
|
}
|
|
|
|
// --- A capture that opens AFTER note-on (a positive start trims the attack) ---
|
|
{
|
|
NoteProgram p;
|
|
p.start = StartOffset(offsetFromMs(100.0)); // positive = later: the head is cut
|
|
p.end = EndOffset(offsetFromMs(100.0));
|
|
const ResolvedNote r = resolveNote(p, at(120.0));
|
|
const auto plan = planBake(r, 48000, 60).plan;
|
|
CHECK(plan.has_value());
|
|
// Window is [0.1, 0.6] s = 0.5 s of FILE, but the note starts 0.1 s before it, so
|
|
// the render must produce that head and throw it away rather than shift the note.
|
|
CHECK(plan->totalFrames == 24000);
|
|
CHECK(plan->leadInFrames == 4800);
|
|
CHECK(plan->renderFrames() == 28800);
|
|
CHECK(plan->noteOnFrame == 0); // the note is at the START of the render
|
|
CHECK(plan->noteOffFrame == 24000); // still its full 0.5 s length
|
|
CHECK(plan->noteOffFrame - plan->noteOnFrame == 24000);
|
|
}
|
|
|
|
// --- Refusals, and which one each condition reports -----------------------------
|
|
{
|
|
NoteProgram p;
|
|
// An end offset more negative than the note length inverts the window.
|
|
p.end = EndOffset(offsetFromMs(-10000.0));
|
|
const ResolvedNote r = resolveNote(p, at(120.0));
|
|
CHECK(r.windowCollapsed);
|
|
CHECK(planBake(r, 48000, 60).refusal == BakeRefusal::EmptyWindow);
|
|
}
|
|
{
|
|
NoteProgram plain;
|
|
const ResolvedNote r = resolveNote(plain, at(120.0));
|
|
CHECK(planBake(r, 0, 60).refusal == BakeRefusal::EmptyWindow);
|
|
CHECK(planBake(r, -48000, 60).refusal == BakeRefusal::EmptyWindow);
|
|
}
|
|
{
|
|
// A legal but sub-frame window rounds to nothing and is refused rather than
|
|
// rendered as a degenerate buffer.
|
|
NoteProgram p;
|
|
p.end = EndOffset(offsetFromMs(-500.0)); // exactly cancels the 0.5 s note
|
|
const ResolvedNote r = resolveNote(p, at(120.0));
|
|
CHECK(!r.windowCollapsed);
|
|
CHECK(r.captureLengthSeconds() == 0.0);
|
|
CHECK(planBake(r, 48000, 60).refusal == BakeRefusal::EmptyWindow);
|
|
}
|
|
{
|
|
// A legal offset magnitude reaches days: refused at the ceiling, not attempted as
|
|
// an allocation (and never narrowed out of int64's range on the way there). This
|
|
// refusal reads differently to the user — a real sound that will not fit, not an
|
|
// empty window — so it must be a distinct value, not just a nullopt.
|
|
const double overSeconds =
|
|
(static_cast<double>(kMaxBakeFrames) / 48000.0) + 1.0;
|
|
NoteProgram p;
|
|
p.end = EndOffset(offsetFromMs(overSeconds * 1000.0));
|
|
const ResolvedNote big = resolveNote(p, at(120.0));
|
|
CHECK(!big.windowCollapsed);
|
|
CHECK(planBake(big, 48000, 60).refusal == BakeRefusal::PastFrameCeiling);
|
|
|
|
// The extreme a legal OffsetAmount can hold, in both directions.
|
|
NoteProgram huge;
|
|
huge.end = EndOffset(offsetFromMs(kMaxConvertibleMagnitude));
|
|
CHECK(planBake(resolveNote(huge, at(120.0)), 48000, 60).refusal ==
|
|
BakeRefusal::PastFrameCeiling);
|
|
NoteProgram far;
|
|
far.start = StartOffset(offsetFromMs(-kMaxConvertibleMagnitude));
|
|
CHECK(planBake(resolveNote(far, at(120.0)), 48000, 60).refusal ==
|
|
BakeRefusal::PastFrameCeiling);
|
|
|
|
// And just under it still plans, so the ceiling is a bound, not a blanket refusal.
|
|
NoteProgram fits;
|
|
fits.end = EndOffset(offsetFromMs(
|
|
(static_cast<double>(kMaxBakeFrames) / 48000.0 - 1.0) * 1000.0));
|
|
const PlannedBake planned = planBake(resolveNote(fits, at(120.0)), 48000, 60);
|
|
CHECK(planned.plan.has_value());
|
|
CHECK(planned.refusal == BakeRefusal::None);
|
|
CHECK(planned.plan && planned.plan->renderFrames() <= kMaxBakeFrames);
|
|
}
|
|
|
|
// --- Domain clamps -------------------------------------------------------------
|
|
{
|
|
NoteProgram p;
|
|
p.end = EndOffset(offsetFromMs(100.0));
|
|
const ResolvedNote r = resolveNote(p, at(120.0));
|
|
const auto low = planBake(r, 48000, -5).plan;
|
|
const auto high = planBake(r, 48000, 900).plan;
|
|
const auto mid = planBake(r, 48000, 60).plan;
|
|
CHECK(low.has_value() && high.has_value() && mid.has_value());
|
|
if (low && high && mid) {
|
|
CHECK(low->note == 0);
|
|
CHECK(high->note == 127);
|
|
CHECK(mid->note == 60);
|
|
}
|
|
}
|
|
|
|
if (g_fail == 0) std::printf("bake_plan: all tests passed\n");
|
|
return g_fail ? 1 : 0;
|
|
}
|