(
// Auto-split part 03 of 10 from Dorota_LegacyCore_v8_9l.scd


~assignFormantsFrameV548 = { |detected, prevTracks, count = 5|
    var out, used, pairs;
    out = Array.fill(count, nil);
    used = Array.fill(detected.size, false);
    pairs = Array.new;
    count.do { |trackIdx|
        var old, oldFreq;
        old = if(prevTracks.notNil and: { prevTracks[trackIdx].notNil }) { prevTracks[trackIdx] } { ~emptyFormantStateV548.(trackIdx) };
        oldFreq = old[\freq] ? 0.0;
        detected.do { |fm, fmIdx|
            var cost, orderPenalty, gainPenalty;
            cost = if(oldFreq > 0.0 and: { (old[\confidence] ? 0.0) > 0.05 }) {
                (fm[\freq].max(20.0).log2 - oldFreq.max(20.0).log2).abs
            } {
                ((fmIdx - trackIdx).abs * 0.09) + (trackIdx * 0.002)
            };
            orderPenalty = if(fmIdx != trackIdx) { 0.018 * (fmIdx - trackIdx).abs } { 0.0 };
            gainPenalty = if((old[\gain] ? 0.0) > 0.0) { ((fm[\gain] - old[\gain]).abs * 0.04) } { 0.0 };
            pairs = pairs.add([cost + orderPenalty + gainPenalty, trackIdx, fmIdx]);
        };
    };
    pairs = pairs.sort { |a, b| a[0] < b[0] };
    pairs.do { |triplet|
        var cost, trackIdx, fmIdx, oldConf, jumpLimit;
        cost = triplet[0];
        trackIdx = triplet[1];
        fmIdx = triplet[2];
        oldConf = if(prevTracks.notNil and: { prevTracks[trackIdx].notNil }) { prevTracks[trackIdx][\confidence] ? 0.0 } { 0.0 };
        jumpLimit = if(oldConf > 0.55) { ~formantTrackMaxJumpOctV548 } { ~formantTrackMaxJumpOctV548 * 1.45 };
        if(out[trackIdx].isNil and: { used[fmIdx].not } and: { cost <= jumpLimit }) {
            out[trackIdx] = detected[fmIdx];
            used[fmIdx] = true;
        };
    };
    out
};

~smoothFormantWithInertiaV548 = { |cur, old, vel|
    var oldFreq, rawJumpOct, dampedJump, newFreq, freqVel, gainVel, gain, conf;
    if(vel.isNil) { vel = [0.0, 0.0] };
    if(cur.isNil) {
        if(old.isNil or: { (old[\freq] ? 0.0) <= 0.0 }) {
            [nil, [0.0, 0.0]]
        } {
            [
                old.copy.put(\gain, (old[\gain] ? 0.0) * 0.91).put(\confidence, ((old[\confidence] ? 0.0) * 0.84).clip(0.0, 1.0)),
                [vel[0] * 0.4, vel[1] * 0.4]
            ]
        }
    } {
        if(old.isNil or: { (old[\freq] ? 0.0) <= 0.0 } or: { (old[\confidence] ? 0.0) <= 0.02 }) {
            [cur.copy.put(\confidence, 0.30), [0.0, 0.0]]
        } {
            oldFreq = (old[\freq] ? cur[\freq]).max(20.0);
            rawJumpOct = cur[\freq].max(20.0).log2 - oldFreq.log2;
            dampedJump = if(rawJumpOct.abs > ~formantMaxJumpOctV548) {
                rawJumpOct.sign * (~formantMaxJumpOctV548 + ((rawJumpOct.abs - ~formantMaxJumpOctV548) * 0.22))
            } { rawJumpOct };
            freqVel = (vel[0] * ~formantVelocityDampV548) + (dampedJump * (1.0 - ~formantVelocityDampV548));
            newFreq = 2.0 ** (oldFreq.log2 + (freqVel * 0.5));
            newFreq = newFreq + ((cur[\freq] - newFreq) * ~formantTrackSmoothV548);
            gainVel = (vel[1] * 0.68) + (((cur[\gain] ? 0.0) - (old[\gain] ? 0.0)) * 0.32);
            gain = (old[\gain] ? 0.0) + (gainVel * 0.5);
            conf = ((old[\confidence] ? 0.0) * 0.82 + ((cur[\confidence] ? 0.35) * 0.18)).clip(0.0, 1.0);
            [
                (
                    id: old[\id] ? cur[\id],
                    freq: newFreq.max(20.0),
                    gain: gain.max(0.0),
                    bw: ((old[\bw] ? ~formantTrackMinBandwidthHzV548) * (1.0 - ~formantTrackBwSmoothV548)) + ((cur[\bw] ? ~formantTrackMinBandwidthHzV548) * ~formantTrackBwSmoothV548),
                    confidence: conf,
                    age: (old[\age] ? 0) + 1,
                    misses: 0
                ),
                [freqVel, gainVel]
            ]
        }
    }
};

~applyFormantBoundsV548 = { |smoothedFormants|
    smoothedFormants.collect { |fm, idx|
        var lo, hi, strength, freq, clamped;
        if(fm.isNil) {
            fm
        } {
            if(idx < ~formantSlotBoundsV548.size) {
                lo = ~formantSlotBoundsV548[idx][0];
                hi = ~formantSlotBoundsV548[idx][1];
                strength = ~formantSlotBoundStrengthV548.asFloat.clip(0.0, 1.0);
                freq = fm[\freq] ? 0.0;
                clamped = if(freq < lo) { freq + ((lo - freq) * strength) } { if(freq > hi) { freq - ((freq - hi) * strength) } { freq } };
                fm.copy.put(\freq, clamped)
            } { fm }
        }
    }
};

~trackFormantsV548 = { |tracks, meta = nil|
    var nFrames, count, history, prev, velocities;
    if(tracks.isNil or: { tracks.isEmpty }) {
        []
    } {
        nFrames = tracks[0][\points].size;
        count = ~formantTrackCountV548.asInteger.max(1);
        history = Array.newClear(nFrames);
        prev = Array.fill(count, { |idx| ~emptyFormantStateV548.(idx) });
        velocities = Array.fill(count, { [0.0, 0.0] });
        nFrames.do { |frameIdx|
            var pts, detected, assigned, curStates;
            pts = tracks.collect { |tr| tr[\points][frameIdx] };
            detected = ~detectFormantsFrameV548.(pts, count);
            assigned = ~assignFormantsFrameV548.(detected, prev, count);
            curStates = Array.fill(count, { |idx|
                var cur, old, vel, res, state, conf, gain, age, misses;
                cur = assigned[idx];
                old = prev[idx] ? ~emptyFormantStateV548.(idx);
                vel = velocities[idx] ? [0.0, 0.0];
                res = ~smoothFormantWithInertiaV548.(cur, old, vel);
                velocities[idx] = res[1];
                state = res[0];
                if(state.isNil) {
                    ~emptyFormantStateV548.(idx)
                } {
                    conf = state[\confidence] ? 0.0;
                    gain = state[\gain] ? 0.0;
                    age = state[\age] ? ((old[\age] ? 0) + if(cur.notNil) { 1 } { 0 });
                    misses = if(cur.notNil) { 0 } { (old[\misses] ? 0) + 1 };
                    if(conf < 0.015) {
                        ~emptyFormantStateV548.(idx)
                    } {
                        (id: idx, freq: state[\freq] ? 0.0, gain: gain.max(0.0), bw: (state[\bw] ? ~formantTrackMinBandwidthHzV548).clip(~formantTrackMinBandwidthHzV548, ~formantTrackMaxBandwidthHzV548), confidence: conf, age: age, misses: misses)
                    }
                }
            });
            curStates = ~applyFormantBoundsV548.(curStates);

            (count - 1).do { |idx|
                var a, b, mid;
                a = curStates[idx];
                b = curStates[idx + 1];
                if((a[\freq] ? 0.0) > 0.0 and: { (b[\freq] ? 0.0) > 0.0 } and: { a[\freq] >= b[\freq] }) {
                    mid = (a[\freq] + b[\freq]) * 0.5;
                    a[\freq] = (mid * 0.96).max(~formantTrackMinFreqV548);
                    b[\freq] = (mid * 1.04).min(~formantTrackMaxFreqV548);
                };
            };
            history[frameIdx] = curStates;
            prev = curStates;
        };
        if(meta.notNil) {
            meta[\formantTracksV548] = history;
            meta[\formantTrackingV548] = true;
            meta[\formantTrackCountV548] = count;
        };
        history
    }
};

~formantTrackGainAtFreqV548 = { |formants, freq|
    var sum, weightSum;
    sum = 0.0;
    weightSum = 0.0;
    if(formants.notNil) {
        formants.do { |fm|
            if(fm.notNil and: { (fm[\confidence] ? 0.0) > ~formantTrackMinConfidenceV548 } and: { (fm[\freq] ? 0.0) > 0.0 }) {
                var distHz, sigma, weight;
                distHz = (freq.max(20.0) - (fm[\freq] ? freq).max(20.0)).abs;
                sigma = (fm[\bw] ? ~formantTrackMinBandwidthHzV548).max(~formantTrackMinBandwidthHzV548);
                weight = exp((distHz.squared.neg) / (2.0 * sigma.squared)) * (fm[\confidence] ? 0.0).clip(0.0, 1.0);
                sum = sum + ((fm[\gain] ? 0.0).asFloat.max(0.0) * weight);
                weightSum = weightSum + weight;
            };
        };
    };
    if(weightSum > 1e-9) { sum / weightSum } { nil }
};

~applyFormantTrackingFrameV548 = { |origPts, movedPts, formants, transient = false|
    var out, strength;
    if(~formantTrackingV548.not or: { formants.isNil } or: { transient and: { ~transientProtectionV546 } }) {
        movedPts
    } {
        strength = ~formantTrackStrengthV548.asFloat.clip(0.0, 1.0);
        out = movedPts.deepCopy;
        out.size.do { |idx|
            var pt, origPt, oldGain, newGain, raw, gain, newAmp;
            pt = out[idx];
            origPt = origPts[idx];
            if(pt.notNil and: { origPt.notNil }) {
                oldGain = ~formantTrackGainAtFreqV548.(formants, (origPt[1] ? (pt[1] ? 0.0)).asFloat.max(20.0));
                newGain = ~formantTrackGainAtFreqV548.(formants, (pt[1] ? 0.0).asFloat.max(20.0));
                if(oldGain.notNil and: { newGain.notNil and: { newGain > 1e-12 } }) {
                    raw = (oldGain / newGain).clip(0.42, 2.35);
                    gain = 1.0 + ((raw - 1.0) * strength);
                    newAmp = ((pt[2] ? 0.0).asFloat.max(0.0) * gain).clip(0.0, 1.0);
                    out[idx] = [pt[0], pt[1], newAmp, pt[3]] ++ if(pt.size > 4) { pt.copyRange(4, pt.size - 1) } { [] };
                };
            };
        };
        out
    }
};


~formantEnvelopePointsV547 = ~formantEnvelopePointsV548;
~detectFormantsFrameV547 = ~detectFormantsFrameV548;
~assignFormantsFrameV547 = ~assignFormantsFrameV548;
~trackFormantsV547 = ~trackFormantsV548;
~formantTrackGainAtFreqV547 = ~formantTrackGainAtFreqV548;
~applyFormantTrackingFrameV547 = ~applyFormantTrackingFrameV548;


~phaseUnwrapPredictedV542 = { |phase, prevPhase, prevFreq, curFreq, frameDur|
    var myPi, twoPi, predicted, diff;
    myPi = 3.141592653589793;
    twoPi = myPi * 2.0;
    if(prevPhase.isNil) {
        phase ? 0.0
    } {
        predicted = prevPhase + (twoPi * ((prevFreq.max(0.0) + curFreq.max(0.0)) * 0.5) * frameDur);
        diff = (phase ? 0.0) - predicted;
        while { diff > myPi } { diff = diff - twoPi };
        while { diff < myPi.neg } { diff = diff + twoPi };
        predicted + diff
    }
};


~phaseContinuityTracksV542 = { |tracks, frameDur|
    frameDur = frameDur ? 0.01;
    tracks.collect { |tr|
        var lastPhase, lastFreq, n, pts;
        lastPhase = nil;
        lastFreq = nil;
        n = (tr[\points] ? []).size;
        pts = (tr[\points] ? []).collect { |pt, pointIdx|
            var safe, curFreq, curAmp, ph;
            safe = ~safePt.(pt, pointIdx, n, 440.0);
            curFreq = safe[1].max(0.0);
            curAmp = safe[2].max(0.0);
            if(curAmp > 1e-9) {
                ph = ~phaseUnwrapPredictedV542.(safe[3] ? 0.0, lastPhase, lastFreq ? curFreq, curFreq, frameDur);
                lastPhase = ph;
                lastFreq = curFreq;
            } {
                ph = safe[3] ? 0.0;
                lastPhase = nil;
                lastFreq = nil;
            };
            [safe[0], curFreq, curAmp, ph] ++ if(safe.size > 4) { [safe[4] ? 0.0] } { [] }
        };
        tr.copy.put(\points, pts)
    }
};

~stampStablePartialIdsV542 = { |tracks, source = \unknown|
    tracks.collect { |tr, idx|
        var copy, oldId;
        oldId = tr[\id] ? idx;
        copy = tr.copy;
        copy[\id] = idx;
        copy[\sourcePartialId] = tr[\sourcePartialId] ? oldId;
        copy[\stablePartialId] = tr[\stablePartialId] ? oldId;
        copy[\trackingSource] = source;
        copy
    }
};

~partialIdOrderReportV542 = { |tracks, label = "partials"|
    var head;
    head = tracks.copyRange(0, (tracks.size - 1).min(11)).collect { |tr, idx|
        idx.asString ++ "<-" ++ (tr[\stablePartialId] ? tr[\sourcePartialId] ? tr[\id] ? idx).asString
    }.join(" ");
    ("PARTIAL-ID STABILITY " ++ label ++ " | count=" ++ tracks.size ++ " | order " ++ head).postln;
};

~smrPsychoFallbackV542 = { |pt, ampMax = 1.0|
    // Fallback-SMR auf Basis der Absoluten Hörschwelle (Terhardt 1979)
    var amp, freq, rel, levelDbFs, levelDbSpl, athSpl, smr;
    amp = (pt[2] ? 0.0).asFloat.max(0.0);
    freq = (pt[1] ? 1000.0).asFloat.max(20.0);
    rel = (amp / ampMax.max(1e-12)).clip(1e-12, 1.0);
    levelDbFs = (20.0 * log10(rel)).clip(-120.0, 0.0);
    levelDbSpl = levelDbFs + (~smrRefSplV542 ? 96.0);
    athSpl = ~athTerhardtV542.(freq);
    smr = (levelDbSpl - athSpl).clip(0.0, 60.0);
    smr
};


~freqToBarkV542 = { |freq|
    var f;
    f = freq.max(20.0);
    13.0 * atan(f * 0.00076) + (3.5 * atan((f / 7500.0) ** 2))
};

// --- Psychoakustik: Absolute Hörschwelle (ATH) ---
// Kalibrierung: 0 dBFS entspricht refSPL dB SPL (Standard: 96 dB SPL = Vollaussteuerung)
~smrRefSplV542 = ~smrRefSplV542 ? 96.0;

// Absolute Threshold of Hearing nach Terhardt (1979), Ergebnis in dB SPL
~athTerhardtV542 = { |freq|
    var f, t;
    f = freq.max(20.0) / 1000.0;  // in kHz
    t = (3.64 * (f ** -0.8))
      - (6.5 * exp(-0.6 * ((f - 3.3) ** 2)))
      + (0.001 * (f ** 4));
    t.clip(-10.0, 120.0)
};

// ATH in dBFS umgerechnet (relativ zu Vollaussteuerung)
~athDbFsV542 = { |freq, refSpl|
    ~athTerhardtV542.(freq) - (refSpl ? (~smrRefSplV542 ? 96.0))
};
// --- Ende ATH ---


~maskingSpreadV542 = { |maskerDb, dBark|
    if(dBark.abs < 0.001) {
        maskerDb
    } {
        if(dBark > 0) {
            maskerDb - (27.0 * dBark)
        } {
            maskerDb - ((6.0 + (0.4 * maskerDb.max(0.0))) * dBark.abs)
        }
    }
};


~maskingThresholdV542 = { |allPts, targetIdx, ampMax|
    var targetPt, targetFreq, targetBark, threshold;
    targetPt = allPts[targetIdx];
    threshold = -200.0;
    if(targetPt.notNil) {
        targetFreq = (targetPt[1] ? 1000.0).asFloat.max(20.0);
        targetBark = ~freqToBarkV542.(targetFreq);
        // ATH als physikalische Basismaske (ersetzt willkürliche -200 dB)
        threshold = ~athDbFsV542.(targetFreq);
        allPts.do { |maskerPt, maskerIdx|
            if(maskerIdx != targetIdx and: { maskerPt.notNil }) {
                var maskerFreq, maskerAmp, maskerDb, maskerBark, dBark, contrib;
                maskerFreq = (maskerPt[1] ? 1000.0).asFloat.max(20.0);
                maskerAmp = (maskerPt[2] ? 0.0).asFloat.max(0.0);
                maskerDb = (20.0 * log10((maskerAmp / ampMax.max(1e-12)).clip(1e-12, 1.0))).clip(-120.0, 0.0);
                maskerBark = ~freqToBarkV542.(maskerFreq);
                dBark = maskerBark - targetBark;
                contrib = ~maskingSpreadV542.(maskerDb, dBark);
                threshold = threshold.max(contrib);
            };
        };
    };
    threshold
};


~recomputeSmrAllFramesV542 = { |tracks, smoothAlpha = 0.28|
    var nTracks, nFrames, ampMax;
    if(tracks.isNil or: { tracks.isEmpty }) {
        tracks
    } {
        nTracks = tracks.size;
        nFrames = tracks[0][\points].size;
        ampMax = 1e-12;
        tracks.do { |tr|
            tr[\points].do { |pt|
                if(pt.notNil) { ampMax = ampMax.max((pt[2] ? 0.0).asFloat) };
            };
        };
        nFrames.do { |frameIdx|
            var allPts;
            allPts = tracks.collect { |tr| tr[\points][frameIdx] };
            nTracks.do { |trackIdx|
                var pt, targetAmp, targetDb, threshold, smr;
                pt = tracks[trackIdx][\points][frameIdx];
                if(pt.notNil) {
                    targetAmp = (pt[2] ? 0.0).asFloat.max(0.0);
                    if(targetAmp > 1e-12) {
                        targetDb = (20.0 * log10((targetAmp / ampMax).clip(1e-12, 1.0))).clip(-120.0, 0.0);
                        threshold = ~maskingThresholdV542.(allPts, trackIdx, ampMax);
                        smr = (targetDb - threshold).clip(0.0, 60.0);
                    } {
                        smr = 0.0
                    };
                    tracks[trackIdx][\points][frameIdx] = [pt[0], pt[1], pt[2], pt[3], smr]
                        ++ if(pt.size > 5) { pt.copyRange(5, pt.size - 1) } { [] };
                };
            };
        };
        tracks.do { |tr|
            var prevSmr;
            prevSmr = 0.0;
            tr[\points] = (tr[\points] ? []).collect { |pt|
                if(pt.isNil) {
                    pt
                } {
                    var raw, smoothed;
                    raw = (pt[4] ? 0.0).asFloat;
                    smoothed = prevSmr + (smoothAlpha * (raw - prevSmr));
                    prevSmr = smoothed;
                    [pt[0], pt[1], pt[2], pt[3], smoothed]
                        ++ if(pt.size > 5) { pt.copyRange(5, pt.size - 1) } { [] }
                }
            };
        };
        tracks
    }
};


// ============================================================
// Psychoakustisches Partial-Pruning v5.42
//
// Entfernt Partiellen, die unterhalb der kombinierten Maske aus
//   (1) Absoluter Hörschwelle (ATH, Terhardt 1979)
//   (2) Simultanmaskierung durch benachbarte Partiellen (Bark-Spreading)
// liegen. Ein Partial gilt als inaudible wenn sein SMR <= smrMin.
//
// Parameter:
//   smrMin          – SMR-Grenze in dB (0 = exakt an Maske, >0 = aggressiver)
//   minActiveFrames – Mindest-Frames mit SMR>smrMin, damit Track erhalten bleibt
//   keepEmptyTracks – komplett gemaskete Tracks behalten (grau, amp=0)
//   recomputeSmr    – SMR vor dem Pruning neu berechnen (empfohlen: true)
//   smoothAlpha     – SMR-Glättungsfaktor (an recomputeSmrAllFramesV542 weitergegeben)
//
// Gibt neues Array zurück; Original wird NICHT verändert.
// Stats landen in ~psychoPruneStatsV542.
// ============================================================
~psychoPruneStatsV542 = nil;

~psychoPruneTracksV542 = { |tracks, smrMin = 0.0, minActiveFrames = 2,
                              keepEmptyTracks = false, recomputeSmr = true,
                              smoothAlpha = 0.28|
    var work, nTracks, nFrames, ampMax,
        activePerTrack, maskedPoints, activePoints, removedTracks, result;

    if(tracks.isNil or: { tracks.isEmpty }) {
        "psychoPruneTracksV542: keine Tracks übergeben.".postln;
        tracks
    } {
        // --- Tiefe Kopie: Original bleibt unberührt ---
        work = tracks.collect { |tr|
            ~mkTrack.(
                tr[\id],
                (tr[\points] ? []).copy,  // shallow copy reicht: Elemente werden ersetzt, nie mutiert
                tr[\color] ? Color.white
            )
        };

        // --- SMR mit ATH + Simultanmaskierung aktuell berechnen ---
        if(recomputeSmr) {
            work = ~recomputeSmrAllFramesV542.(work, smoothAlpha);
        };

        nTracks    = work.size;
        nFrames    = if(nTracks > 0) { (work[0][\points] ? []).size } { 0 };
        ampMax     = 1e-12;
        work.do { |tr|
            (tr[\points] ? []).do { |pt|
                if(pt.notNil) { ampMax = ampMax.max((pt[2] ? 0.0).asFloat) };
            };
        };

        maskedPoints  = 0;
        activePoints  = 0;
        removedTracks = 0;
        activePerTrack = Array.newClear(nTracks);

        // --- Punkt-für-Punkt: Amplitude nullen wenn SMR <= smrMin ---
        nTracks.do { |ti|
            var active;
            active = 0;
            work[ti][\points] = (work[ti][\points] ? []).collect { |pt|
                if(pt.isNil) {
                    pt
                } {
                    var smr, amp, masked;
                    smr    = (pt[4] ? 0.0).asFloat;
                    amp    = (pt[2] ? 0.0).asFloat;
                    masked = (smr <= smrMin) or: { amp <= 1e-12 };
                    if(masked) {
                        maskedPoints = maskedPoints + 1;
                        // Zeitstempel + Frequenz erhalten; Amplitude und SMR auf 0
                        [pt[0], pt[1], 0.0, (pt[3] ? 0.0)]
                            ++ if(pt.size > 4) {
                                [0.0] ++ if(pt.size > 5) { pt.copyRange(5, pt.size - 1) } { [] }
                            } { [] }
                    } {
                        active       = active + 1;
                        activePoints = activePoints + 1;
                        pt
                    }
                }
            };
            activePerTrack[ti] = active;
        };

        // --- Tracks mit zu wenig aktiven Frames entfernen ---
        result = List.new;
        nTracks.do { |ti|
            if(activePerTrack[ti] >= minActiveFrames) {
                result.add(work[ti]);
            } {
                removedTracks = removedTracks + 1;
                if(keepEmptyTracks) {
                    result.add(
                        ~mkTrack.(work[ti][\id], work[ti][\points], Color.grey(0.30))
                    );
                };
            };
        };

        result = result.asArray.collect { |tr, idx| tr.copy.put(\id, idx) };

        // --- Stats ---
        ~psychoPruneStatsV542 = (
            version:         "v5.42",
            smrMin:          smrMin,
            minActiveFrames: minActiveFrames,
            inputTracks:     nTracks,
            outputTracks:    result.size,
            removedTracks:   removedTracks,
            frames:          nFrames,
            activePoints:    activePoints,
            maskedPoints:    maskedPoints,
            totalPoints:     activePoints + maskedPoints,
            maskedRatio:     maskedPoints / (activePoints + maskedPoints).max(1),
            smrRefSpl:       ~smrRefSplV542 ? 96.0
        );

        ("PSYCHO PRUNE v5.42"
            ++ " | tracks " ++ nTracks ++ "->" ++ result.size
            ++ " | removed=" ++ removedTracks
            ++ " | smrMin=" ++ smrMin
            ++ " | active=" ++ activePoints
            ++ " | masked=" ++ maskedPoints
            ++ " | ratio=" ++ (~psychoPruneStatsV542[\maskedRatio]).round(0.001)
            ++ " | refSPL=" ++ (~smrRefSplV542 ? 96.0)).postln;

        result
    }
};
// ============================================================
// Ende Psychoakustisches Partial-Pruning
// ============================================================

~psychoPruneExportV542 = ~psychoPruneExportV542 ? false;
~psychoPruneExportSmrMinV542 = ~psychoPruneExportSmrMinV542 ? 0.0;
~psychoPruneExportMinActiveFramesV542 = ~psychoPruneExportMinActiveFramesV542 ? 2;

~applyPsychoPruneForExportV542 = { |tracks, label = \export|
    var outTracks, st;
    if((~psychoPruneExportV542 ? false) and: { ~psychoPruneTracksV542.notNil }) {
        outTracks = ~psychoPruneTracksV542.(
            tracks,
            ~psychoPruneExportSmrMinV542 ? 0.0,
            ~psychoPruneExportMinActiveFramesV542 ? 2,
            false,
            true,
            0.28
        );
        st = ~psychoPruneStatsV542;
        if(st.notNil) {
            ("PSYCHO PRUNE EXPORT v5.42 | " ++ label.asString
                ++ " | tracks " ++ (st[\inputTracks] ? 0) ++ "->" ++ (st[\outputTracks] ? 0)
                ++ " | smrMin=" ++ (~psychoPruneExportSmrMinV542 ? 0.0)
                ++ " | maskedRatio=" ++ ((st[\maskedRatio] ? 0.0).round(0.001))).postln;
        };
        outTracks
    } {
        tracks
    }
};


~prepareTracksForAtsExportV542 = { |tracks, meta, usePhaseContinuity = true, retuneSmr = true|
    var frameDur, out;
    frameDur = if(meta.notNil) {
        var dur, nFrames;
        dur = (meta[\dur] ? 1.0).asFloat.max(0.001);
        nFrames = (meta[\frames] ? tracks[0][\points].size).asInteger.max(2);
        dur / (nFrames - 1).asFloat
    } {
        0.01
    };
    out = ~advancedSpectralProcessV546.(tracks, meta);
    out = if(usePhaseContinuity) { ~phaseContinuityTracksV542.(out, frameDur) } { out };
    if(retuneSmr and: { ~smrPsychoTuneV542 }) {
        out = ~recomputeSmrAllFramesV542.(out);
    };
    if(~partialIdStabilityV542) {
        out = ~stampStablePartialIdsV542.(out, \export);
    };
    out
};


~estimateSmrV542 = { |pt, ampMax = 1.0|
    if(pt.notNil and: { pt.size > 4 and: { pt[4].notNil } }) {
        pt[4]
    } {
        ~smrPsychoFallbackV542.(pt ? [0.0, 1000.0, 0.0, 0.0], ampMax)
    }
};
~atsFrameStructV541 = { |frameIdx, frameTime, tracks, atsKind, ampMax = 1.0, bandEnergy = nil, includeSmr = true|
    var hasPhase, hasNoise, partialFrames, noiseBands;
    hasPhase = (atsKind == 2) or: { atsKind == 4 };
    hasNoise = (atsKind == 3) or: { atsKind == 4 };
    partialFrames = tracks.collect { |tr|
        var pt;
        pt = tr[\points][frameIdx];
        (
            amp: if(pt.notNil) { (pt[2] ? 0.0).asFloat.max(0.0) } { 0.0 },
            freq: if(pt.notNil) { (pt[1] ? 0.0).asFloat.max(0.0) } { 0.0 },
            phase: if(hasPhase and: { pt.notNil }) { (pt[3] ? 0.0) } { 0.0 },
            smr: if(includeSmr and: { pt.notNil }) { ~estimateSmrV542.(pt, ampMax) } { nil }
        )
    };
    noiseBands = if(hasNoise and: { bandEnergy.notNil }) {
        Array.fill(25, { |bi| var row; row = bandEnergy[frameIdx]; if(row.notNil) { (row[bi] ? 0.0).asFloat.max(0.0) } { 0.0 } })
    } {
        nil
    };
    (
        time: frameTime,
        partials: partialFrames,
        noise: noiseBands,
        hasPhase: hasPhase,
        hasNoise: hasNoise,
        hasSmr: includeSmr
    )
};


~exportReimportCheckV61 = true;


~exportSourceV64 = \raw;
~exportUsePlaybackDataV63 = false;

~compareAtsDataV541 = { |a, b|
    var metaA, metaB, tracksA, tracksB, frames, partials, maxFreqErr, maxAmpErr, maxPhaseErr, maxSmrErr, ok;
    metaA = a[\meta]; metaB = b[\meta];
    tracksA = a[\tracks]; tracksB = b[\tracks];
    frames = (metaA[\frames] ? 0).asInteger.min((metaB[\frames] ? 0).asInteger);
    partials = (metaA[\partials] ? 0).asInteger.min((metaB[\partials] ? 0).asInteger);
    maxFreqErr = 0.0; maxAmpErr = 0.0; maxPhaseErr = 0.0; maxSmrErr = 0.0;
    partials.do { |partIdx|
        frames.do { |frameIdx|
            var p1, p2;
            p1 = tracksA[partIdx][\points][frameIdx];
            p2 = tracksB[partIdx][\points][frameIdx];
            if(p1.notNil and: { p2.notNil }) {
                maxFreqErr = maxFreqErr.max(((p1[1] ? 0.0) - (p2[1] ? 0.0)).abs);
                maxAmpErr = maxAmpErr.max(((p1[2] ? 0.0) - (p2[2] ? 0.0)).abs);
                maxPhaseErr = maxPhaseErr.max((~wrapPhaseV541.((p1[3] ? 0.0) - (p2[3] ? 0.0))).abs);
                maxSmrErr = maxSmrErr.max(((p1[4] ? 0.0) - (p2[4] ? 0.0)).abs);
            };
        };
    };
    ok = ((metaA[\partials] == metaB[\partials]) and: { (metaA[\frames] == metaB[\frames]) })
        and: { maxFreqErr < 1e-7 and: { maxAmpErr < 1e-9 } };
    (
        ok: ok,
        partialsA: metaA[\partials], partialsB: metaB[\partials],
        framesA: metaA[\frames], framesB: metaB[\frames],
        typeA: metaA[\type], typeB: metaB[\type],
        hasSmrA: metaA[\hasSmrWord], hasSmrB: metaB[\hasSmrWord],
        maxFreqErr: maxFreqErr, maxAmpErr: maxAmpErr, maxPhaseErr: maxPhaseErr, maxSmrErr: maxSmrErr
    )
};
~saveAtsFileStrictV541 = { |path, tracks, meta, bandEnergy = nil|
    var file, partials, frames, sr, dur, frameSize, winSize, ampMax, freqMax, atsKind;
    var hasPhase, hasNoise, includeSmr, bandCount, frameIdx, partIdx, bandIdx, pt, frameTime, result;
    result = nil;
    if(tracks.isNil or: { tracks.isEmpty }) {
        "BINARY EXACT ROUNDTRIP export failed: no tracks".postln;
    } {
        partials = (meta[\partials] ? tracks.size).asInteger;
        frames = (meta[\frames] ? tracks[0][\points].size).asInteger;
        sr = (meta[\sr] ? 44100).asFloat;
        dur = (meta[\dur] ? 0.001).asFloat.max(0.001);
        frameSize = (meta[\frameSize] ? 1).asFloat;
        winSize = (meta[\windowSize] ? 1).asFloat;
        ampMax = (meta[\ampmax] ? 0.0).asFloat;
        freqMax = (meta[\frqmax] ? 0.0).asFloat;
        atsKind = (meta[\type] ? 4).asInteger.clip(1, 4);
        hasPhase = (atsKind == 2) or: { atsKind == 4 };
        hasNoise = (atsKind == 3) or: { atsKind == 4 };
        includeSmr = if((meta[\hasSmrWord] ? false) == true) { true } { false };
        bandCount = (meta[\bandCount] ? if(hasNoise) { 25 } { 0 }).asInteger;
        if(bandCount <= 0 and: { hasNoise }) { bandCount = 25 };
        file = File(path, "wb");
        if(file.isOpen.not) {
            "BINARY EXACT ROUNDTRIP export failed: file not open".postln;
        } {
            [~atsMagicNumber, sr, frameSize, winSize, partials.asFloat, frames.asFloat, ampMax, freqMax, dur, atsKind.asFloat].do { |x|
                ~writeF64LE.(file, x);
            };
            frameIdx = 0;
            while { frameIdx < frames } {
                pt = tracks[0][\points][frameIdx];
                frameTime = if(pt.notNil) { ((pt[0] ? (frameIdx / (frames - 1).max(1))) * dur) } { (frameIdx / (frames - 1).max(1)) * dur };
                ~writeF64LE.(file, frameTime);
                partIdx = 0;
                while { partIdx < partials } {
                    pt = tracks[partIdx][\points][frameIdx];
                    ~writeF64LE.(file, if(pt.notNil) { pt[2] ? 0.0 } { 0.0 });
                    ~writeF64LE.(file, if(pt.notNil) { pt[1] ? 0.0 } { 0.0 });
                    if(hasPhase) {
                        ~writeF64LE.(file, if(pt.notNil) { pt[3] ? 0.0 } { 0.0 });
                    };
                    if(includeSmr) {
                        ~writeF64LE.(file, if(pt.notNil and: { pt.size > 4 }) { pt[4] ? 0.0 } { 0.0 });
                    };
                    partIdx = partIdx + 1;
                };
                if(hasNoise) {
                    bandIdx = 0;
                    while { bandIdx < bandCount } {
                        ~writeF64LE.(file, if(bandEnergy.notNil and: { bandEnergy[frameIdx].notNil }) { bandEnergy[frameIdx][bandIdx] ? 0.0 } { 0.0 });
                        bandIdx = bandIdx + 1;
                    };
                };
                frameIdx = frameIdx + 1;
            };
            file.close;
            ("BINARY EXACT ROUNDTRIP exported: " ++ path
                ++ " | partials=" ++ partials
                ++ " | frames=" ++ frames
                ++ " | type=" ++ atsKind
                ++ " | smr=" ++ includeSmr
                ++ " | bands=" ++ bandCount).postln;
            result = path;
        };
    };
    result
};
~shellQuoteV541 = { |path|
    var str;
    str = path.asString.replace("'", "'\''");
    "'" ++ str ++ "'"
};
~binaryExactCopyAtsV541 = { |inPath, outPath|
    var cmd, reply, ok;
    cmd = "cp -f " ++ ~shellQuoteV541.(inPath) ++ " " ++ ~shellQuoteV541.(outPath) ++ " && echo OK || echo FAIL";
    reply = cmd.unixCmdGetStdOut.stripWhiteSpace;
    ok = reply == "OK";
    if(ok) {
        ("BINARY EXACT copied: " ++ inPath ++ " -> " ++ outPath).postln;
        outPath
    } {
        ("BINARY EXACT copy failed: " ++ reply ++ " cmd=" ++ cmd).postln;
        nil
    }
};
~binaryExactCompareAtsV541 = { |pathA, pathB|
    var cmd, reply, same;
    cmd = "cmp -s " ++ ~shellQuoteV541.(pathA) ++ " " ++ ~shellQuoteV541.(pathB) ++ " && echo SAME || echo DIFFER";
    reply = cmd.unixCmdGetStdOut.stripWhiteSpace;
    same = reply == "SAME";
    ("BINARY EXACT cmp: " ++ same ++ " | " ++ reply).postln;
    same
};
~roundtripAtsFileV541 = { |inPath, outPath = nil|
    var first, exportPath, copied, second, same;
    first = ~loadAtsFileV541.(inPath);
    if(first.isNil) {
        "BINARY EXACT ROUNDTRIP FAILED: import returned nil".postln;
        nil
    } {
        exportPath = outPath ? (PathName(inPath).pathOnly ++ PathName(inPath).fileNameWithoutExtension ++ "_v541_binary_exact.ats");
        copied = ~binaryExactCopyAtsV541.(inPath, exportPath);
        if(copied.isNil) {
            "BINARY EXACT ROUNDTRIP FAILED: raw copy returned nil".postln;
            nil
        } {
            same = ~binaryExactCompareAtsV541.(inPath, exportPath);
            second = ~loadAtsFileV541.(exportPath);
            if(second.isNil) {
                "BINARY EXACT ROUNDTRIP FAILED: reimport returned nil".postln;
                nil
            } {
                ("BINARY EXACT ROUNDTRIP " ++ if(same) { "BIT-IDENTICAL" } { "DIFFERS" }
                    ++ " | out=" ++ exportPath
                    ++ " | partials " ++ first[\meta][\partials] ++ "->" ++ second[\meta][\partials]
                    ++ " | frames " ++ first[\meta][\frames] ++ "->" ++ second[\meta][\frames]
                    ++ " | type " ++ first[\meta][\type] ++ "->" ++ second[\meta][\type]
                    ++ " | smr " ++ first[\meta][\hasSmrWord] ++ "->" ++ second[\meta][\hasSmrWord]).postln;
                (
                    ok: same,
                    binaryExact: same,
                    outPath: exportPath,
                    partialsA: first[\meta][\partials], partialsB: second[\meta][\partials],
                    framesA: first[\meta][\frames], framesB: second[\meta][\frames],
                    typeA: first[\meta][\type], typeB: second[\meta][\type],
                    hasSmrA: first[\meta][\hasSmrWord], hasSmrB: second[\meta][\hasSmrWord]
                )
            };
        };
    };
};
~saveAtsFileV541 = { |path, tracks, meta, bandEnergy = nil, forcedType = 4, includeSmr = false|
    var file, partials, frames, sr, dur, frameSize, winSize, ampMax, freqMax, atsKind, times, exportTracks;
    var frameIdx, partIdx, bandIdx, pt, result, hasPhase, hasNoise, safeBandEnergy, actualBandEnergy, frameStruct, partStruct;
    result = nil;
    if(path.notNil and: { path.isString }) {
        if(PathName(path).extension.asString.toLower != "ats") {
            path = path ++ ".ats";
            ("ATS export auto-extension v7.4 | path=" ++ path).postln;
        };
    };
    if(tracks.isNil or: { tracks.isEmpty }) {
        "ATS export failed: no tracks".postln;
    } {
        // v10.0z5: SPEAR/ATSA canonical ATS files do not serialize an extra per-partial SMR word.
        // Keep SMR for internal scoring only; export amp/freq[/phase] + optional 25 noise bands.
        includeSmr = false;
        exportTracks = ~prepareTracksForAtsExportV542.(tracks, meta, ~phaseContinuityV542, includeSmr);
        partials = exportTracks.size;
        frames = exportTracks[0][\points].size;
        if(frames <= 1) {
            "ATS export failed: not enough frames".postln;
        } {
            sr = (meta[\sr] ? 44100).asFloat.max(1.0);
            dur = (meta[\dur] ? 0.0).asFloat;
            if(dur <= 0.001) { dur = ((frames - 1) * ((meta[\frameSize] ? 441).asFloat)) / sr };
            dur = dur.max(0.001);
            frameSize = (meta[\frameSize] ? 0).asInteger;
            if(frameSize <= 0) {
                frameSize = ((dur * sr) / (frames - 1).max(1)).round.asInteger.max(1);
            };
            winSize = (meta[\windowSize] ? ((frameSize * 4) + 1)).asInteger.max(1);

            if(winSize <= frameSize) {
                winSize = (frameSize * 2) + 1;
            };
            if(winSize.even) {
                winSize = winSize + 1;
            };
            ampMax = 0.0;
            freqMax = 0.0;
            exportTracks.do { |tr|
                tr[\points].do { |onePt|
                    if(onePt.notNil) {
                        ampMax = ampMax.max((onePt[2] ? 0.0).asFloat);
                        freqMax = freqMax.max((onePt[1] ? 0.0).asFloat);
                    };
                };
            };
            atsKind = forcedType.asInteger.clip(1, 4);
            hasPhase = (atsKind == 2) or: { atsKind == 4 };
            hasNoise = (atsKind == 3) or: { atsKind == 4 };
            safeBandEnergy = Array.fill(frames, { FloatArray.fill(25, 0.0) });
            if(hasNoise and: { bandEnergy.notNil and: { bandEnergy.size == frames } }) {
                frames.do { |fi|
                    25.do { |bi|
                        safeBandEnergy[fi][bi] = (bandEnergy[fi][bi] ? 0.0).asFloat.max(0.0);
                    };
                };
            };
            actualBandEnergy = if(hasNoise) { safeBandEnergy } { nil };
            times = Array.fill(frames, { |idx|
                (idx.asFloat / (frames - 1).asFloat.max(1.0)) * dur
            });
            file = File(path, "wb");
            if(file.isOpen.not) {
                "ATS export failed: file not open".postln;
            } {
                [~atsMagicNumber, sr, frameSize, winSize, partials.asFloat, frames.asFloat, ampMax, freqMax, dur, atsKind.asFloat].do { |x|
                    ~writeF64LE.(file, x);
                };
                frameIdx = 0;
                while { frameIdx < frames } {
                    frameStruct = ~atsFrameStructV541.(frameIdx, times[frameIdx], exportTracks, atsKind, ampMax, actualBandEnergy, includeSmr);
                    ~writeF64LE.(file, frameStruct[\time]);
                    partIdx = 0;
                    while { partIdx < partials } {
                        partStruct = frameStruct[\partials][partIdx];
                        ~writeF64LE.(file, partStruct[\amp] ? 0.0);
                        ~writeF64LE.(file, partStruct[\freq] ? 0.0);
                        if(hasPhase) {
                            ~writeF64LE.(file, partStruct[\phase] ? 0.0);
                        };
                        // v10.0z5: intentionally no serialized SMR word here.
                        // Type 1: amp/freq; Type 2: amp/freq/phase;
                        // Type 3: amp/freq + 25 bands; Type 4: amp/freq/phase + 25 bands.
                        partIdx = partIdx + 1;
                    };
                    if(hasNoise) {
                        bandIdx = 0;
                        while { bandIdx < 25 } {
                            ~writeF64LE.(file, frameStruct[\noise][bandIdx] ? 0.0);
                            bandIdx = bandIdx + 1;
                        };
                    };
                    frameIdx = frameIdx + 1;
                };
                file.close;
                ("ATS exported: " ++ path
                    ++ " | partials=" ++ partials
                    ++ " | frames=" ++ frames
                    ++ " | dur=" ++ dur.round(0.001)
                    ++ " | type=" ++ atsKind
                    ++ " | frameSize=" ++ frameSize
                    ++ " | win=" ++ winSize
                    ++ " | smrSerialized=false").postln;
                result = path;
            };
        };
    };
    result
};
~verifyAtsFileV541 = { |path|
    var res, meta;
    res = ~loadAtsFileV541.(path);
    if(res.isNil) {
        "VERIFY ATS FAILED".postln;
        false
    } {
        meta = res[\meta];
        ("VERIFY ATS OK | partials=" ++ (meta[\partials] ? -1)
            ++ " frames=" ++ (meta[\frames] ? -1)
            ++ " type=" ++ (meta[\type] ? -1)
            ++ " dur=" ++ (meta[\dur] ? 0.0).round(0.001)
            ++ " ampmax=" ++ (meta[\ampmax] ? 0.0).round(0.000001)
            ++ " frqmax=" ++ (meta[\frqmax] ? 0.0).round(0.001)).postln;
        true
    }
};

~exportValidationV61 = { |path, expectedTracks, expectedFrames, expectedType, expectedSmr, doReimport = true|
    var verifyOK, reimport, meta, partialsOK, framesOK, typeOK, smrOK, ok;
    verifyOK = ~verifyAtsFileV541.(path);
    if(verifyOK.not) {
        "EXPORT VALIDATION FAILED: verify returned false".postln;
        false
    } {
        if(doReimport.not) {
            "EXPORT VALIDATION OK: verify only; reimport check skipped".postln;
            true
        } {
            reimport = ~loadAtsFileV541.(path);
            if(reimport.isNil) {
                "EXPORT VALIDATION FAILED: reimport returned nil".postln;
                false
            } {
                meta = reimport[\meta];
                partialsOK = (meta[\partials].asInteger == expectedTracks.asInteger);
                framesOK = (meta[\frames].asInteger == expectedFrames.asInteger);
                typeOK = (meta[\type].asInteger == expectedType.asInteger);
                smrOK = ((meta[\hasSmrWord] ? false) == expectedSmr);
                ok = partialsOK and: { framesOK and: { typeOK and: { smrOK } } };
                ("EXPORT REIMPORT " ++ if(ok) { "OK" } { "CHECK" }
                    ++ " | partials " ++ expectedTracks ++ "->" ++ meta[\partials]
                    ++ " | frames " ++ expectedFrames ++ "->" ++ meta[\frames]
                    ++ " | type " ++ expectedType ++ "->" ++ meta[\type]
                    ++ " | smr " ++ expectedSmr ++ "->" ++ (meta[\hasSmrWord] ? false)).postln;
                ok
            }
        }
    }
};
)
