S-VIEW-9: velocity->amp transfer curve (pure velocity_curve module + zones-payload v7 + Voice::start apply)

Default flat y=1 (R10-F1 Option A) replaces the linear velocity/127 at note-on — a deliberate, non-back-compat behavior change; v1-v6 blobs lift to the flat default.

src/vst/sample_map.cpp

@@ -219,6 +219,9 @@ ResolvedPerformance resolvePerformance(const std::string& banksJson,
         // S-VIEW-6: the key-tracking scalar is instrument state (not a bank fact) — carried
         // straight through to the resolved zone and applied in the repitch math at play time.
         rz.keyTrack = z.keyTrack;
+        // S-VIEW-9: the velocity->amp curve is likewise instrument state — carried through and
+        // eval'd at Voice::start to set the voice's amp gain from the note-on velocity.
+        rz.velocityCurve = z.velocityCurve;
         // Effective loop / start (S11): the instrument's per-zone override wins over the
         // bank's S2 intrinsic; absent -> the intrinsic (loop) / frame 0 (start). The bank is
         // never mutated — this only shapes what the core plays for THIS instance (D-B).
@@ -264,6 +267,7 @@ Keymap buildZonedKeymap(const std::vector<ResolvedZone>& zones,
         zone.highNote = zones[i].highNote;
         zone.rootNote = zones[i].rootNote;
         zone.keyTrack = zones[i].keyTrack;  // S-VIEW-6: applied in keyTrackedRatio at play time
+        zone.velocityCurve = zones[i].velocityCurve;  // S-VIEW-9: eval'd in Voice::start
         zone.sampleIndex = sampleIndex;
         km.zones.push_back(zone);
     }
@@ -407,8 +411,16 @@ void putZonesPayload(std::vector<std::uint8_t>& out, const PerformanceMap& map)
         putU64le(out, doubleToBits(pp.adsr.decaySeconds));
         putU64le(out, doubleToBits(pp.adsr.sustainLevel));
         putU64le(out, doubleToBits(pp.adsr.releaseSeconds));
-        // PAYLOAD v6 (S-VIEW-6): the per-zone key-tracking scalar, appended last (1.0 = 100% ET).
+        // PAYLOAD v6 (S-VIEW-6): the per-zone key-tracking scalar (1.0 = 100% ET).
         putU64le(out, doubleToBits(z.keyTrack));
+        // PAYLOAD v7 (S-VIEW-9): the per-zone velocity->amp transfer curve, appended last. 4-byte LE
+        // control-point count, then per point velocity + amp as IEEE-754 doubles (endpoints included).
+        const std::vector<reasampler::vst::VelocityPoint>& pts = z.velocityCurve.points();
+        putU32le(out, static_cast<std::uint32_t>(pts.size()));
+        for (const reasampler::vst::VelocityPoint& p : pts) {
+            putU64le(out, doubleToBits(p.velocity));
+            putU64le(out, doubleToBits(p.amp));
+        }
     }
 }
 
@@ -430,7 +442,8 @@ void readZonesPayload(ByteReader& r, PerformanceMap& map, double projectRate) {
     }
     const bool legacyV3Play = (pv == 3);  // legacy S15/S16 play tail, wall-clock in 44.1k frames
     const bool secondsPlay  = (pv >= 5);  // v5+: full play params, wall-clock in seconds
-    const bool keyTrackTail = (pv >= 6);  // v6+ (S-VIEW-6): per-zone keyTrack scalar appended last
+    const bool keyTrackTail = (pv >= 6);  // v6+ (S-VIEW-6): per-zone keyTrack scalar
+    const bool curveTail    = (pv >= 7);  // v7+ (S-VIEW-9): per-zone velocity->amp curve, appended last
     const std::uint32_t count = r.u32();
     for (std::uint32_t i = 0; i < count && r.ok; ++i) {
         // z.play defaults to the PRODUCT defaults (Gate + Preserve + tier-0 AHDSR seconds). A
@@ -493,6 +506,26 @@ void readZonesPayload(ByteReader& r, PerformanceMap& map, double projectRate) {
         // payload (no field) leaves the PerformanceZone default (keyTrack = 1.0 = 100% ET), so an
         // already-saved instance repitches BIT-IDENTICALLY to the pre-S-VIEW-6 engine.
         if (keyTrackTail) z.keyTrack = bitsToDouble(r.u64());
+        // PAYLOAD v7 (S-VIEW-9): the velocity->amp transfer curve, appended after the v6 keyTrack. A
+        // pre-v7 payload (no field) leaves the PerformanceZone default (VelocityCurve::flat() — R10-F1
+        // Option A, flat y=1), the deliberate NON-back-compat behavior change for already-saved zones.
+        // fromPoints repairs the X-order/endpoint invariant defensively; a truncated read (r.ok flips
+        // false mid-curve) leaves the flat default and the mid-zone break below drops the rest.
+        if (curveTail) {
+            const std::uint32_t ptCount = r.u32();
+            std::vector<reasampler::vst::VelocityPoint> pts;
+            // Bound the reserve to what the blob can actually hold (16 bytes/point) so a corrupt huge
+            // count can't trigger a giant allocation before the bounded reads fail — the loop still
+            // stops on r.ok, this only caps the speculative reserve.
+            const std::size_t remaining = r.bytes.size() > r.pos ? r.bytes.size() - r.pos : 0;
+            pts.reserve(std::min(static_cast<std::size_t>(ptCount), remaining / 16));
+            for (std::uint32_t p = 0; p < ptCount && r.ok; ++p) {
+                const double vel = bitsToDouble(r.u64());
+                const double amp = bitsToDouble(r.u64());
+                pts.push_back(reasampler::vst::VelocityPoint{vel, amp});
+            }
+            if (r.ok) z.velocityCurve = reasampler::vst::VelocityCurve::fromPoints(std::move(pts));
+        }
         // Payload versions 4 (branch-only frames tail, never shipped) and any unknown pv leave the
         // seconds product defaults on z.play — a v4 blob cannot exist outside this branch.
         if (!r.ok) break;  // truncated mid-zone -> keep what parsed cleanly, drop the rest