daniel
a80eb76c1f
Division and OffsetAmount get single normalizing doors and private constructors; fromBpm validates by running the conversions rather than their reciprocal. Readers drop their re-clamps and default labels.
76 lines
3.1 KiB
C++
76 lines
3.1 KiB
C++
// musical_division — the note-length ladder the capture signal is programmed from: 1/64
|
|
// through 64/1, each straight, dotted, or triplet. Lengths are in BEATS only; the tempo
|
|
// resolution belongs to `tempo`, which keeps this ladder provable without one.
|
|
|
|
#pragma once
|
|
|
|
#include <cstdint>
|
|
#include <string>
|
|
#include <type_traits>
|
|
|
|
namespace reasampler::instrument::note {
|
|
|
|
enum class DivisionModifier : std::uint8_t {
|
|
Straight,
|
|
Dotted, // x 3/2
|
|
Triplet, // x 2/3
|
|
};
|
|
|
|
// A rung of the ladder is the base-2 exponent of its length in quarter notes: -4 is 1/64,
|
|
// 0 is 1/4, 2 is 1/1, 8 is 64/1. Holding the exponent rather than a table of literal beat
|
|
// counts keeps every straight and dotted length exactly representable in double.
|
|
inline constexpr int kMinQuarterExponent = -4;
|
|
inline constexpr int kMaxQuarterExponent = 8;
|
|
inline constexpr int kRungCount = kMaxQuarterExponent - kMinQuarterExponent + 1;
|
|
inline constexpr int kModifierCount = 3;
|
|
inline constexpr int kDivisionCount = kRungCount * kModifierCount;
|
|
|
|
// The longest programmable note — the dotted top rung — so a caller composing this ladder
|
|
// with the tempo conversions can check the two domains against each other at compile time.
|
|
inline constexpr double kMaxDivisionBeats = (1 << kMaxQuarterExponent) * 1.5;
|
|
|
|
class Division;
|
|
|
|
// Off-ladder inputs clamp rather than reject: the only ways to reach one are a corrupt
|
|
// persisted record or a picker bug, and the nearest legal length beats a nonsense duration.
|
|
// An unnamed modifier byte has no nearest rung to fall to, so it takes the field's default.
|
|
Division makeDivision(int quarterExponent, DivisionModifier modifier);
|
|
|
|
// In-domain by construction — `makeDivision` is the only door and it clamps BOTH fields, so
|
|
// every reader below trusts the stored pair instead of re-clamping it, and equality compares
|
|
// the two fields raw without disagreeing with any of them.
|
|
class Division {
|
|
public:
|
|
Division() = default; // 1/4 straight
|
|
|
|
constexpr std::int8_t quarterExponent() const { return quarterExponent_; }
|
|
constexpr DivisionModifier modifier() const { return modifier_; }
|
|
|
|
private:
|
|
Division(std::int8_t quarterExponent, DivisionModifier modifier)
|
|
: quarterExponent_(quarterExponent), modifier_(modifier) {}
|
|
friend Division makeDivision(int quarterExponent, DivisionModifier modifier);
|
|
|
|
std::int8_t quarterExponent_ = 0;
|
|
DivisionModifier modifier_ = DivisionModifier::Straight;
|
|
};
|
|
|
|
static_assert(!std::is_constructible_v<Division, int, DivisionModifier>,
|
|
"makeDivision must be the only way to give a Division a rung");
|
|
|
|
bool operator==(Division a, Division b);
|
|
bool operator!=(Division a, Division b);
|
|
|
|
// Length in beats (quarter notes). Always > 0, and never above kMaxDivisionBeats.
|
|
double divisionBeats(Division d);
|
|
|
|
// Picker order: shortest rung first, straight/dotted/triplet within each rung. Index is
|
|
// presentation order only — see this directory's CLAUDE.md before persisting one.
|
|
Division divisionAt(int index);
|
|
int divisionIndex(Division d);
|
|
|
|
// The notation divisions are named in: "1/16", "1/8.", "1/4t", "4/1".
|
|
std::string divisionLabel(Division d);
|
|
|
|
} // namespace reasampler::instrument::note
|