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

~analyzeAudioToTracksV541 = { |path, numTracks = 24, numPoints = 120, minFreq = 40.0, maxFreq = 12000.0|
    var audio, sig, sr, frames, winSize, frameDur, freqs, amps, phases, maxMag, bandEnergy, tracks, lastFreqs, lastAmps, lastPhases, deathFrames, stableIds, nextStableId, birthFrames, ageFrames, birthEvents, deathEvents, result;
    result = nil;
    audio = ~readMonoSoundFile.(path);
    if(audio.isNil) {
        "ANALYZE AUDIO FAILED: could not read file".postln;
        result = nil;
    } {
        sig = audio[\samples];
        sr = audio[\sr];
        frames = audio[\frames];
        winSize = if((numTracks >= 50) and: { numPoints <= 40 }) {
            8192.min(frames).max(1024).nextPowerOfTwo
        } {
            1024.min(frames).max(512).nextPowerOfTwo
        };
        freqs = Array.fill(numTracks, { FloatArray.newClear(numPoints) });
        amps = Array.fill(numTracks, { FloatArray.newClear(numPoints) });
        phases = Array.fill(numTracks, { FloatArray.newClear(numPoints) });
        bandEnergy = Array.fill(numPoints, { FloatArray.newClear(25) });
        maxMag = 1e-9;
        lastFreqs = FloatArray.fill(numTracks, { |idx| (120.0 * (1.18 ** idx)).clip(minFreq, maxFreq) });
        lastAmps = FloatArray.fill(numTracks, 0.0);
        deathFrames = Array.fill(numTracks, 999);
        stableIds = Array.fill(numTracks, { |idx| idx });
        nextStableId = [numTracks];
        lastPhases = Array.fill(numTracks, nil);
        birthFrames = Array.fill(numTracks, -1);
        ageFrames = Array.fill(numTracks, 0);
        birthEvents = Array.fill(numTracks, { Array.new });
        deathEvents = Array.fill(numTracks, { Array.new });
        frameDur = (frames / sr) / (numPoints - 1).max(1);
        ("analysis uses " ++ numTracks ++ " tracks / " ++ numPoints ++ " frames / " ++ winSize ++ " FFT with ATS-CUDA/Lisp tracking + TRUE residual subtraction + compact calibrated noise bands v7.4").postln;
        numPoints.do { |frameIdx|
            var t, start, peaks, assigned;
            t = frameIdx / (numPoints - 1).max(1);
            start = ((frames - winSize).max(0) * t).round.asInteger.clip(0, (frames - winSize).max(0));
            peaks = ~findSpectralPeaksV541.(sig, start, winSize, sr, minFreq, maxFreq, numTracks * 3);
            {
                var assignedNow;
                assignedNow = ~birthDeathAssignPeaksV69ar.(peaks, lastFreqs, lastAmps, lastPhases, deathFrames, stableIds, nextStableId, birthFrames, ageFrames, 2, 0.32, frameDur);
                assignedNow.do { |pk, trackIdx|
                    if(pk.notNil) {
                        freqs[trackIdx][frameIdx] = pk[\freq];
                        amps[trackIdx][frameIdx] = pk[\mag];
                        phases[trackIdx][frameIdx] = ~unwrapPeakPhaseV69ar.(pk[\phase], lastPhases[trackIdx], lastFreqs[trackIdx], pk[\freq], frameDur);
                        if((pk[\birth] ? false) or: { (deathFrames[trackIdx] ? 999) > 1 }) {
                            birthFrames[trackIdx] = frameIdx;
                            ageFrames[trackIdx] = 0;
                            birthEvents[trackIdx] = birthEvents[trackIdx].add((frame: frameIdx, stablePartialId: stableIds[trackIdx], freq: pk[\freq], amp: pk[\mag]));
                        } {
                            ageFrames[trackIdx] = (ageFrames[trackIdx] ? 0) + 1;
                        };
                        lastFreqs[trackIdx] = pk[\freq];
                        lastAmps[trackIdx] = pk[\mag];
                        lastPhases[trackIdx] = phases[trackIdx][frameIdx];
                        deathFrames[trackIdx] = 0;
                        maxMag = maxMag.max(pk[\mag]);
                    } {
                        freqs[trackIdx][frameIdx] = lastFreqs[trackIdx];
                        amps[trackIdx][frameIdx] = 0.0;
                        phases[trackIdx][frameIdx] = lastPhases[trackIdx] ? 0.0;
                        if((deathFrames[trackIdx] ? 0) == 0) {
                            deathEvents[trackIdx] = deathEvents[trackIdx].add((frame: frameIdx, stablePartialId: stableIds[trackIdx], lastFreq: lastFreqs[trackIdx], lastAmp: lastAmps[trackIdx]));
                        };
                        lastAmps[trackIdx] = (lastAmps[trackIdx] ? 0.0) * 0.85;
                        deathFrames[trackIdx] = deathFrames[trackIdx] + 1;
                    };
                };
            }.value;
            bandEnergy[frameIdx] = ~fillTrueResidualNoiseBandsV71.(sig, start, winSize, sr, freqs, amps, phases, frameIdx, 0.00115);
            if((frameIdx % 24) == 0) {
                ("analysis progress: " ++ (((frameIdx + 1) / numPoints) * 100).round(1) ++ "%").postln;
            };
        };
        tracks = Array.fill(numTracks, { |trackIdx|
            var pts;
            pts = Array.fill(numPoints, { |frameIdx|
                var t, f, a, ph;
                t = frameIdx / (numPoints - 1).max(1);
                f = if(freqs[trackIdx][frameIdx] > 0) { freqs[trackIdx][frameIdx] } { (120.0 * (1.18 ** trackIdx)).clip(minFreq, maxFreq) };
                a = ((amps[trackIdx][frameIdx] / maxMag.max(1e-9)) * 0.18).clip(0.0, 0.18);
                ph = phases[trackIdx][frameIdx];
                [t, f, a, ph]
            });
            {
                var tr;
                tr = ~mkTrack.(trackIdx, pts, Color.hsv(trackIdx / numTracks.max(1), 0.7, 0.85));
                tr[\stableId] = stableIds[trackIdx];
                tr[\stablePartialId] = stableIds[trackIdx];
                tr[\birthFrame] = birthFrames[trackIdx];
                tr[\deathFrames] = deathFrames[trackIdx];
                tr[\ageFrames] = ageFrames[trackIdx];
                tr[\birthEvents] = birthEvents[trackIdx];
                tr[\deathEvents] = deathEvents[trackIdx];
                tr[\phaseCoherentTracking] = true;
                tr[\persistentPartialIdentity] = true;
                tr[\birthDeathTracking] = true;
                tr
            }.value
        });
        if(~harmonicLockingV544) {
            tracks = ~harmonicLockTracksV544.(tracks, nil);
        };
        result = (
            tracks: tracks,
            meta: (
                sr: sr,
                frames: numPoints,
                sourceFrames: frames,
                dur: frames / sr,
                path: path,
                analysisMode: \audioAnalysisPriority1V69ar,
                source: \audioFile,
                windowSize: winSize,
                frameSize: ((frames / (numPoints - 1).max(1)).round.asInteger.max(1)),
                partials: tracks.size,
                type: 2,
                selectedStats: ~makeImportStats.(tracks),
                selectedOriginalIdx: (0 .. (tracks.size - 1)),
                candidateTrackCount: tracks.size,
                birthDeathTracking: true,
                persistentPartialIdentity: true,
                phaseCoherentTracking: true,
                priority1: \birthDeathStableIdsPhaseCoherent,
                priority2: \trueResidualNoiseBandsV69az,
                residualModel: \trueSinusoidalSubtraction25BandsV71,
                phaseType: \accumulated,
                phaseUnwrapped: true
            ),
            bandEnergy: ~residualTiltCompensateV69ba.(~smoothResidualBandsV69az.(bandEnergy, tracks), 0.92, 1.08, 1.0, 0.35),
            residualModel: \trueResidualSubtractionTiltV71,
            residualPreTilt: ~smoothResidualBandsV69az.(bandEnergy, tracks)
        );
    };
    result
};


~priority1EnforcePlaybackV69at = { |tracks, meta = nil, relDb = -34.0, absFloor = 0.00045, phaseJumpOct = 0.38|
    var globalMax, frameDur, out;
    if(tracks.isNil) { nil } {
        globalMax = 0.0;
        tracks.do { |tr|
            (tr[\points] ? []).do { |pt|
                if(pt.notNil) { globalMax = globalMax.max((pt[2] ? 0.0).asFloat.max(0.0)) };
            };
        };
        frameDur = if(meta.notNil and: { meta[\dur].notNil } and: { tracks.notNil } and: { tracks.size > 0 } and: { (tracks[0][\points] ? []).size > 1 }) {
            (meta[\dur].asFloat / (((tracks[0][\points] ? []).size - 1).max(1))).max(0.000001)
        } { 0.01 };
        out = tracks.collect { |tr, trackIdx|
            var pts, peak, thresh, newPts, first, last, gaps, activeCount, birthEvents, deathEvents, inSegment, lastPhase, lastFreq, stableId;
            pts = (tr[\points] ? []);
            peak = 0.0;
            pts.do { |pt| if(pt.notNil) { peak = peak.max((pt[2] ? 0.0).asFloat.max(0.0)) } };
            thresh = absFloor.max(peak * (10.0 ** (relDb / 20.0))).max(globalMax * 0.0015);
            first = nil; last = nil; gaps = 0; activeCount = 0;
            birthEvents = Array.new; deathEvents = Array.new; inSegment = false;
            lastPhase = nil; lastFreq = nil;
            stableId = tr[\stablePartialId] ? tr[\stableId] ? tr[\sourcePartialId] ? trackIdx;
            newPts = pts.collect { |pt, frameIdx|
                var t, f, a, ph, active, prevActive, ratioJump, unwrapped;
                if(pt.isNil) { pt = [frameIdx / ((pts.size - 1).max(1)), 0.0, 0.0, 0.0] };
                t = (pt[0] ? (frameIdx / ((pts.size - 1).max(1)))).asFloat;
                f = (pt[1] ? 0.0).asFloat.max(0.0);
                a = (pt[2] ? 0.0).asFloat.max(0.0);
                ph = (pt[3] ? 0.0).asFloat;
                ratioJump = if(lastFreq.notNil and: { f > 0.0 }) { (f.max(1.0).log2 - lastFreq.max(1.0).log2).abs } { 0.0 };
                active = (a > thresh) and: { f > 0.0 } and: { ratioJump <= phaseJumpOct };
                if(active) {
                    if(inSegment.not) {
                        birthEvents = birthEvents.add((frame: frameIdx, stablePartialId: stableId, freq: f, amp: a));
                    };
                    unwrapped = ~unwrapPeakPhaseV69ar.(ph, lastPhase, lastFreq, f, frameDur);
                    first = first ?? { frameIdx };
                    last = frameIdx;
                    activeCount = activeCount + 1;
                    inSegment = true;
                    lastPhase = unwrapped;
                    lastFreq = f;
                    [t, f, a, unwrapped]
                } {
                    if(inSegment) {
                        deathEvents = deathEvents.add((frame: frameIdx, stablePartialId: stableId, lastFreq: lastFreq ? f, lastAmp: a));
                    };
                    if(first.notNil and: { last.notNil }) { gaps = gaps + 1 };
                    inSegment = false;
                    [t, if(lastFreq.notNil) { lastFreq } { f }, 0.0, lastPhase ? ph]
                };
            };
            {
                var nt;
                nt = tr.copy;
                nt[\points] = newPts;
                nt[\stableId] = stableId;
                nt[\stablePartialId] = stableId;
                nt[\persistentPartialIdentity] = true;
                nt[\birthDeathTracking] = true;
                nt[\phaseCoherentTracking] = true;
                nt[\birthFrame] = first;
                nt[\deathFrame] = if(last.notNil and: { last < (pts.size - 1) }) { last + 1 } { nil };
                nt[\firstActiveFrame] = first;
                nt[\lastActiveFrame] = last;
                nt[\activeFrames] = activeCount;
                nt[\inactiveFrames] = pts.size - activeCount;
                nt[\gapFrames] = gaps;
                nt[\birthEvents] = birthEvents;
                nt[\deathEvents] = deathEvents;
                nt[\phaseType] = if(meta.notNil) { meta[\phaseType] ? \accumulated } { tr[\phaseType] ? \accumulated };
                nt[\phaseUnwrapped] = (nt[\phaseType] == \accumulated);
                nt
            }.value
        };
        ("PRIORITY1 v6.9at enforced on playback | tracks=" ++ out.size
            ++ " | frames=" ++ if(out.size > 0) { out[0][\points].size } { 0 }
            ++ " | relDb=" ++ relDb ++ " | absFloor=" ++ absFloor).postln;
        out
    }
};


~atsMagicNumber = 123.0;
~readF64LE = { |file| file.getDoubleLE };
~readF32LE = { |file| file.getFloatLE };
~readF64BE = { |file| file.getDouble };
~readF32BE = { |file| file.getFloat };
~writeF64LE = { |file, value| file.putDoubleLE(value ? 0.0) };
~atsHeaderOK = { |sr, frameSize, winSize, partials, frames, ampMax, freqMax, dur, atsKind|
    sr.isNumber and: { sr >= 1000.0 and: { sr <= 384000.0 } }
    and: { partials.isNumber and: { partials >= 1 and: { partials <= 200000 } } }
    and: { frames.isNumber and: { frames >= 1 and: { frames <= 2000000 } } }
    and: { dur.isNumber and: { dur > 0.0 and: { dur < 86400.0 } } }
    and: { [1, 2, 3, 4].includes(atsKind.asInteger) }
};
~parseATSWith = { |path, readFunc, wordBytes, endianName|
    var file, fileSize, magic, sr, frameSize, winSize, partialsF, framesF, ampMax, freqMax, dur, atsKindF;
    var partials, frames, atsKind, hasPhase, hasNoise, baseWords, actualBytes;
    var expectedNoSmr25, expectedSmr25, expectedNoSmr10, expectedSmr10, expectedNoNoise, expectedNoNoiseSmr;
    var hasSmr, bandCount, tracks, bandEnergy, frameIdx, partIdx, bandIdx, frameTime, amp, freq, phase, smr, energy, result;
    result = nil;
    hasSmr = false;
    bandCount = 0;
    file = File(path, "rb");
    if(file.isOpen.not) {
        ("ATS import failed: file not open: " ++ path).postln;
        result = nil;
    } {
        fileSize = file.length.asInteger;
        magic = readFunc.(file);
        ("ATS debug: wordBytes=" ++ wordBytes ++ " endian=" ++ endianName ++ " magic=" ++ magic).postln;
        if((magic - ~atsMagicNumber).abs >= 0.001) {
            file.close;
            result = nil;
        } {
            sr = readFunc.(file);
            frameSize = readFunc.(file);
            winSize = readFunc.(file);
            partialsF = readFunc.(file);
            framesF = readFunc.(file);
            ampMax = readFunc.(file);
            freqMax = readFunc.(file);
            dur = readFunc.(file);
            atsKindF = readFunc.(file);
            partials = partialsF.round.asInteger;
            frames = framesF.round.asInteger;
            atsKind = atsKindF.round.asInteger;
            ("ATS candidate header | " ++ wordBytes ++ "-byte " ++ endianName
                ++ " | sr=" ++ sr ++ " frameSize=" ++ frameSize ++ " win=" ++ winSize
                ++ " partials=" ++ partialsF ++ " frames=" ++ framesF
                ++ " ampmax=" ++ ampMax ++ " frqmax=" ++ freqMax ++ " dur=" ++ dur
                ++ " type=" ++ atsKindF).postln;
            if(~atsHeaderOK.(sr, frameSize, winSize, partials, frames, ampMax, freqMax, dur, atsKind).not) {
                ("ATS candidate rejected: invalid header for " ++ wordBytes ++ "-byte " ++ endianName).postln;
                file.close;
                result = nil;
            } {
                hasPhase = (atsKind == 2) or: { atsKind == 4 };
                hasNoise = (atsKind == 3) or: { atsKind == 4 };
                baseWords = if(hasPhase) { 3 } { 2 };
                actualBytes = fileSize - (10 * wordBytes);
                if(hasNoise) {
                    expectedNoSmr25 = frames * wordBytes * (1 + (partials * baseWords) + 25);
                    expectedSmr25 = frames * wordBytes * (1 + (partials * (baseWords + 1)) + 25);
                    expectedNoSmr10 = frames * wordBytes * (1 + (partials * baseWords) + 10);
                    expectedSmr10 = frames * wordBytes * (1 + (partials * (baseWords + 1)) + 10);
                    if(actualBytes == expectedNoSmr25) { hasSmr = false; bandCount = 25 } {
                        if(actualBytes == expectedSmr25) { hasSmr = true; bandCount = 25 } {
                            if(actualBytes == expectedNoSmr10) { hasSmr = false; bandCount = 10 } {
                                if(actualBytes == expectedSmr10) { hasSmr = true; bandCount = 10 } {
                                    hasSmr = false; bandCount = 25;
                                };
                            };
                        };
                    };
                } {
                    expectedNoNoise = frames * wordBytes * (1 + (partials * baseWords));
                    expectedNoNoiseSmr = frames * wordBytes * (1 + (partials * (baseWords + 1)));
                    if(actualBytes == expectedNoNoiseSmr) { hasSmr = true };
                };
                ("ATS header OK | sr=" ++ sr ++ " frameSize=" ++ frameSize ++ " win=" ++ winSize
                    ++ " partials=" ++ partials ++ " frames=" ++ frames ++ " dur=" ++ dur
                    ++ " type=" ++ atsKind ++ " phase=" ++ hasPhase ++ " noise=" ++ hasNoise
                    ++ " bands=" ++ bandCount ++ " smrWord=" ++ hasSmr
                    ++ " format=" ++ wordBytes ++ "-byte-" ++ endianName).postln;
                tracks = Array.fill(partials, { |trackIdx| (id: trackIdx, points: Array.newClear(frames)) });
                bandEnergy = if(hasNoise) { Array.fill(frames, { FloatArray.newClear(25) }) } { nil };
                frameIdx = 0;
                while { frameIdx < frames } {
                    frameTime = readFunc.(file);
                    partIdx = 0;
                    while { partIdx < partials } {
                        amp = readFunc.(file);
                        freq = readFunc.(file);
                        phase = if(hasPhase) { readFunc.(file) } { 0.0 };
                        smr = if(hasSmr) { readFunc.(file) } { 0.0 };
                        tracks[partIdx][\points][frameIdx] = [
                            (frameTime / dur.max(0.001)).clip(0.0, 1.0),
                            if(freq.isNumber) { freq.asFloat.max(0.0) } { 0.0 },
                            if(amp.isNumber) { amp.asFloat.max(0.0) } { 0.0 },
                            if(phase.isNumber) { phase.asFloat } { 0.0 },
                            if(smr.isNumber) { smr.asFloat } { 0.0 }
                        ];
                        partIdx = partIdx + 1;
                    };
                    if(hasNoise) {
                        bandIdx = 0;
                        while { bandIdx < bandCount } {
                            energy = readFunc.(file);
                            if(bandIdx < 25) {
                                bandEnergy[frameIdx][bandIdx] = if(energy.isNumber) { energy.asFloat.max(0.0) } { 0.0 };
                            };
                            bandIdx = bandIdx + 1;
                        };
                    };
                    frameIdx = frameIdx + 1;
                };
                file.close;
                result = (
                    tracks: tracks,
                    meta: (
                        sr: sr.round.asInteger,
                        frames: frames,
                        dur: dur,
                        frameSize: frameSize.round.asInteger.max(1),
                        windowSize: winSize.round.asInteger.max(1),
                        partials: partials,
                        ampmax: ampMax,
                        frqmax: freqMax,
                        type: atsKind,
                        source: \ats,
                        analysisMode: \atsImport,
                        wordBytes: wordBytes,
                        endian: endianName,
                        bandCount: bandCount,
                        hasSmrWord: hasSmr,
                        phaseType: \principal,
                        phaseUnwrapped: false,
                        atsTrueMatrix: true,
                        atsMatrixDisplay: true,
                        atsMatrixPlayback: true,
                        atsCellWidthNorm: (1.0 / frames.max(1)).clip(0.001, 0.25),
                        displayMaxFreq: freqMax,
                        importBypassPost: true,
                        preserveAtsMatrix: true
                    ),
                    bandEnergy: bandEnergy
                );
            };
        };
    };
    result
};
~loadAtsFileV541 = { |path|
    var result;
    result = nil;
    if(path.isNil or: { path.isString.not }) {
        "ATS import failed: invalid path".postln;
    } {
        ("ATS import trying: " ++ path).postln;
        result = ~parseATSWith.(path, ~readF64LE, 8, "LE");
        if(result.isNil) { "ATS import: 64-bit LE failed, trying 32-bit LE...".postln; result = ~parseATSWith.(path, ~readF32LE, 4, "LE") };
        if(result.isNil) { "ATS import: 32-bit LE failed, trying 64-bit BE...".postln; result = ~parseATSWith.(path, ~readF64BE, 8, "BE") };
        if(result.isNil) { "ATS import: 64-bit BE failed, trying 32-bit BE...".postln; result = ~parseATSWith.(path, ~readF32BE, 4, "BE") };
        if(result.isNil) { "ATS import failed: no valid ATS header found.".postln } {
            ("ATS import success: " ++ path).postln;
            "ATS TRUE MATRIX IMPORT v10z | source=.ats | preserves partialIndex x frameIndex | bypasses Dorota smoothing/prune/norm".postln;
        };
    };
    result
};
~wrapPhaseV541 = { |phase|
    var p, twoPi, myPi;
    myPi = 3.141592653589793;
    twoPi = myPi * 2.0;
    p = phase ? 0.0;
    while { p > myPi } { p = p - twoPi };
    while { p < myPi.neg } { p = p + twoPi };
    p
};

~phaseContinuityV542 = true;
~smrPsychoTuneV542 = true;
~partialIdStabilityV542 = true;
~stablePartialIdKeyV542 = \stablePartialId;


~harmonicLockingV544 = true;
~harmonicLockStrengthV544 = 0.72;
~harmonicLockCentsV544 = 38.0;
~harmonicLockMinAmpV544 = 1e-7;
~harmonicLockMaxHarmonicV544 = 64;
~harmonicLockF0MinV544 = 35.0;
~harmonicLockF0MaxV544 = 2000.0;

~centsDiffV544 = { |freqA, freqB|
    if((freqA ? 0.0) <= 0.0 or: { (freqB ? 0.0) <= 0.0 }) {
        1e9
    } {
        (1200.0 * ((freqA.max(1.0) / freqB.max(1.0)).log2)).abs
    }
};

~estimateF0FromFrameV544 = { |pts, minF0 = 35.0, maxF0 = 2000.0|
    var candidates, bestF0, bestScore;
    candidates = Array.new;
    pts.do { |pt|
        var freq, amp;
        if(pt.notNil) {
            freq = (pt[1] ? 0.0).asFloat;
            amp = (pt[2] ? 0.0).asFloat.max(0.0);
            if(freq > 0.0 and: { amp > ~harmonicLockMinAmpV544 }) {
                (1 .. 16).do { |harm|
                    var cand;
                    cand = freq / harm.asFloat;
                    if(cand >= minF0 and: { cand <= maxF0 }) {
                        candidates = candidates.add((f0: cand, weight: amp.sqrt, sourceFreq: freq));
                    };
                };
            };
        };
    };
    bestF0 = nil;
    bestScore = 0.0;
    candidates.do { |cand|
        var score, f0;
        f0 = cand[\f0];
        score = 0.0;
        pts.do { |pt|
            var freq, amp, harm, target, cents, closeness;
            if(pt.notNil) {
                freq = (pt[1] ? 0.0).asFloat;
                amp = (pt[2] ? 0.0).asFloat.max(0.0);
                if(freq > 0.0 and: { amp > ~harmonicLockMinAmpV544 }) {
                    harm = (freq / f0.max(1e-9)).round.asInteger.clip(1, ~harmonicLockMaxHarmonicV544);
                    target = f0 * harm;
                    cents = ~centsDiffV544.(freq, target);
                    if(cents <= 60.0) {
                        closeness = (1.0 - (cents / 60.0)).clip(0.0, 1.0);

                        score = score + (amp.sqrt * closeness * (1.0 / harm.sqrt));
                    };
                };
            };
        };
        if(score > bestScore) {
            bestScore = score;
            bestF0 = f0;
        };
    };
    (f0: bestF0, confidence: bestScore)
};


~formantPreservationV545 = true;
~formantPreservationStrengthV545 = 0.72;
~formantPreservationMinAmpV545 = 1e-12;
~formantPreservationMaxGainV545 = 2.25;
~formantPreservationMinGainV545 = 0.35;

~formantEnvelopeAtFreqV545 = { |framePts, freq|
    var valid, lf, first, last, env, found;
    lf = (freq ? 0.0).asFloat.max(20.0).log2;
    valid = Array.new;
    framePts.do { |pt|
        if(pt.notNil) {
            var f, a;
            f = (pt[1] ? 0.0).asFloat.max(0.0);
            a = (pt[2] ? 0.0).asFloat.max(0.0);
            if(f > 0.0 and: { a > ~formantPreservationMinAmpV545 }) {
                valid = valid.add([f.log2, a.max(~formantPreservationMinAmpV545).ampdb]);
            };
        };
    };
    if(valid.isEmpty) {
        ~formantPreservationMinAmpV545
    } {
        valid = valid.sort { |a, b| a[0] < b[0] };
        first = valid[0];
        last = valid[valid.size - 1];
        if(lf <= first[0]) {
            first[1].dbamp
        } {
            if(lf >= last[0]) {
                last[1].dbamp
            } {
                env = first[1];
                found = false;
                (0 .. (valid.size - 2)).do { |idx|
                    var lo, hi, frac;
                    if(found.not) {
                        lo = valid[idx];
                        hi = valid[idx + 1];
                        if(lf >= lo[0] and: { lf <= hi[0] }) {
                            frac = ((lf - lo[0]) / (hi[0] - lo[0]).max(1e-12)).clip(0.0, 1.0);
                            env = lo[1] + ((hi[1] - lo[1]) * frac);
                            found = true;
                        };
                    };
                };
                env.dbamp.max(~formantPreservationMinAmpV545)
            }
        }
    }
};

~applyFormantPreservationFrameV545 = { |origPts, movedPts, strength = 0.72|
    var st;
    st = (strength ? 0.0).asFloat.clip(0.0, 1.0);
    movedPts.collect { |pt, idx|
        if(pt.isNil) {
            pt
        } {
            var origPt, oldFreq, newFreq, oldEnv, newEnv, rawGain, gain, amp, newAmp;
            origPt = origPts[idx];
            oldFreq = if(origPt.notNil) { (origPt[1] ? (pt[1] ? 0.0)).asFloat } { (pt[1] ? 0.0).asFloat };
            newFreq = (pt[1] ? oldFreq).asFloat;
            amp = (pt[2] ? 0.0).asFloat.max(0.0);
            if(amp <= ~formantPreservationMinAmpV545 or: { oldFreq <= 0.0 } or: { newFreq <= 0.0 }) {
                pt
            } {
                oldEnv = ~formantEnvelopeAtFreqV545.(origPts, oldFreq).max(~formantPreservationMinAmpV545);
                newEnv = ~formantEnvelopeAtFreqV545.(origPts, newFreq).max(~formantPreservationMinAmpV545);
                rawGain = (oldEnv / newEnv).clip(~formantPreservationMinGainV545, ~formantPreservationMaxGainV545);
                gain = 1.0 + ((rawGain - 1.0) * st);
                newAmp = (amp * gain).clip(0.0, 1.0);
                [pt[0], pt[1], newAmp, pt[3]]
                    ++ if(pt.size > 4) { pt.copyRange(4, pt.size - 1) } { [] }
            };
        };
    }
};

~harmonicLockFrameV544 = { |pts, f0, lockStrength = 0.72, lockCents = 38.0|
    if(f0.isNil or: { f0 <= 0.0 }) {
        pts
    } {
        pts.collect { |pt|
            if(pt.isNil) {
                pt
            } {
                var freq, amp, harm, target, cents, amt, lockedFreq;
                freq = (pt[1] ? 0.0).asFloat;
                amp = (pt[2] ? 0.0).asFloat.max(0.0);
                if(freq <= 0.0 or: { amp <= ~harmonicLockMinAmpV544 }) {
                    pt
                } {
                    harm = (freq / f0.max(1e-9)).round.asInteger.clip(1, ~harmonicLockMaxHarmonicV544);
                    target = f0 * harm;
                    cents = ~centsDiffV544.(freq, target);
                    if(cents <= lockCents) {

                        amt = (lockStrength * (1.0 - (cents / lockCents).clip(0.0, 1.0)) * (1.0 / harm.sqrt).clip(0.2, 1.0)).clip(0.0, 1.0);
                        lockedFreq = freq + ((target - freq) * amt);
                        [pt[0], lockedFreq, pt[2], pt[3]]
                            ++ if(pt.size > 4) { pt.copyRange(4, pt.size - 1) } { [] }
                    } {
                        pt
                    };
                };
            };
        }
    }
};

~harmonicLockTracksV544 = { |tracks, meta = nil|
    var nFrames, out, f0History, lastF0;
    if(tracks.isNil or: { tracks.isEmpty }) {
        tracks
    } {
        nFrames = tracks[0][\points].size;
        out = tracks.collect { |tr| tr.copy.put(\points, (tr[\points] ? []).deepCopy) };
        f0History = Array.newClear(nFrames);
        lastF0 = nil;
        nFrames.do { |frameIdx|
            var pts, est, f0, conf, smoothF0, lockedPts;
            pts = out.collect { |tr| tr[\points][frameIdx] };
            est = ~estimateF0FromFrameV544.(pts, ~harmonicLockF0MinV544, ~harmonicLockF0MaxV544);
            f0 = est[\f0];
            conf = est[\confidence] ? 0.0;
            if(f0.notNil and: { conf > 0.0001 }) {
                smoothF0 = if(lastF0.notNil and: { ~centsDiffV544.(f0, lastF0) < 120.0 }) {
                    (lastF0 * 0.82) + (f0 * 0.18)
                } {
                    f0
                };
                lastF0 = smoothF0;
                f0History[frameIdx] = smoothF0;
                lockedPts = ~harmonicLockFrameV544.(pts, smoothF0, ~harmonicLockStrengthV544, ~harmonicLockCentsV544);
                if(~formantPreservationV545) {
                    lockedPts = ~applyFormantPreservationFrameV545.(pts, lockedPts, ~formantPreservationStrengthV545);
                };
                out.size.do { |trackIdx|
                    out[trackIdx][\points][frameIdx] = lockedPts[trackIdx];
                };
            } {
                f0History[frameIdx] = lastF0;
            };
        };
        out.do { |tr| tr[\harmonicLocking] = true };
        if(meta.notNil) {
            meta[\harmonicLockF0] = f0History;
            meta[\harmonicLocking] = true;
        };
        out
    }
};


~envelopeSeparationV546 = true;
~transientProtectionV546 = true;
~phaseLockedVocoderV546 = true;
~transientFluxThresholdV546 = 0.38;
~transientAttackHoldFramesV546 = 2;
~residualEnvelopeStrengthV546 = 0.55;
~harmonicEnvelopeStrengthV546 = 0.70;
~phaseLockRadiusV546 = 3;
~phaseLockMinAmpV546 = 1e-7;

~copyTracksDeepV546 = { |tracks|
    tracks.collect { |tr|
        tr.copy.put(\points, (tr[\points] ? []).deepCopy)
    }
};

~frameEnergyV546 = { |pts|
    var e;
    e = 0.0;
    pts.do { |pt|
        if(pt.notNil) { e = e + ((pt[2] ? 0.0).asFloat.max(0.0).squared) };
    };
    e.max(1e-18)
};

~spectralFluxV546 = { |prevPts, curPts|
    var ePrev, eCur, diff, n;
    if(prevPts.isNil or: { curPts.isNil }) {
        0.0
    } {
        ePrev = ~frameEnergyV546.(prevPts).sqrt;
        eCur = ~frameEnergyV546.(curPts).sqrt;
        diff = (eCur - ePrev) / ePrev.max(1e-9);
        n = curPts.size.max(1);
        diff.clip(0.0, 10.0) / n.sqrt.max(1.0)
    }
};

~transientMapV546 = { |tracks|
    var nFrames, flags, hold;
    if(tracks.isNil or: { tracks.isEmpty }) {
        []
    } {
        nFrames = tracks[0][\points].size;
        flags = Array.fill(nFrames, false);
        hold = 0;
        nFrames.do { |frameIdx|
            var curPts, prevPts, flux;
            curPts = tracks.collect { |tr| tr[\points][frameIdx] };
            prevPts = if(frameIdx > 0) { tracks.collect { |tr| tr[\points][frameIdx - 1] } } { nil };
            flux = ~spectralFluxV546.(prevPts, curPts);
            if(flux > ~transientFluxThresholdV546) { hold = ~transientAttackHoldFramesV546 };
            if(hold > 0) {
                flags[frameIdx] = true;
                hold = hold - 1;
            };
        };
        flags
    }
};

~isHarmonicPartialV546 = { |freq, f0, centsMax = 45.0|
    var harm, target, cents;
    if(f0.isNil or: { f0 <= 0.0 } or: { freq <= 0.0 }) {
        false
    } {
        harm = (freq / f0.max(1e-9)).round.asInteger.clip(1, ~harmonicLockMaxHarmonicV544);
        target = f0 * harm;
        cents = ~centsDiffV544.(freq, target);
        cents <= centsMax
    }
};

~separateFrameV546 = { |pts, f0|
    var harmonicIdx, residualIdx;
    harmonicIdx = Array.new;
    residualIdx = Array.new;
    pts.do { |pt, idx|
        var freq, amp;
        if(pt.notNil) {
            freq = (pt[1] ? 0.0).asFloat;
            amp = (pt[2] ? 0.0).asFloat.max(0.0);
            if(amp > ~formantPreservationMinAmpV545 and: { ~isHarmonicPartialV546.(freq, f0) }) {
                harmonicIdx = harmonicIdx.add(idx);
            } {
                residualIdx = residualIdx.add(idx);
            };
        };
    };
    (harmonic: harmonicIdx, residual: residualIdx)
};

~energyCompensateFrameV546 = { |origPts, newPts, idxs, strength = 1.0|
    var before, after, scale, st;
    st = (strength ? 1.0).asFloat.clip(0.0, 1.0);
    before = 0.0;
    after = 0.0;
    idxs.do { |idx|
        if(origPts[idx].notNil) { before = before + ((origPts[idx][2] ? 0.0).asFloat.max(0.0)) };
        if(newPts[idx].notNil) { after = after + ((newPts[idx][2] ? 0.0).asFloat.max(0.0)) };
    };
    scale = if(after > 1e-12) { (before / after).clip(0.25, 4.0) } { 1.0 };
    scale = 1.0 + ((scale - 1.0) * st);
    idxs.do { |idx|
        var pt;
        pt = newPts[idx];
        if(pt.notNil) {
            newPts[idx] = [pt[0], pt[1], ((pt[2] ? 0.0).asFloat * scale).clip(0.0, 1.0), pt[3]]
                ++ if(pt.size > 4) { pt.copyRange(4, pt.size - 1) } { [] };
        };
    };
    newPts
};

~applyEnvelopeSeparationFrameV546 = { |origPts, movedPts, f0, transient = false|
    var split, hPts, rPts, hStrength, rStrength;
    if(~envelopeSeparationV546.not) {
        movedPts
    } {
        split = ~separateFrameV546.(origPts, f0);
        hStrength = if(transient and: { ~transientProtectionV546 }) { 0.0 } { ~harmonicEnvelopeStrengthV546 };
        rStrength = if(transient and: { ~transientProtectionV546 }) { 0.0 } { ~residualEnvelopeStrengthV546 };
        hPts = ~applyFormantPreservationFrameV545.(origPts, movedPts.deepCopy, hStrength);
        rPts = movedPts.deepCopy;
        split[\residual].do { |idx|
            var pt, origPt, oldFreq, newFreq, oldEnv, newEnv, rawGain, gain, newAmp;
            pt = rPts[idx];
            origPt = origPts[idx];
            if(pt.notNil and: { origPt.notNil }) {
                oldFreq = (origPt[1] ? (pt[1] ? 0.0)).asFloat;
                newFreq = (pt[1] ? oldFreq).asFloat;
                if(oldFreq > 0.0 and: { newFreq > 0.0 }) {
                    oldEnv = ~formantEnvelopeAtFreqV545.(origPts, oldFreq).max(~formantPreservationMinAmpV545);
                    newEnv = ~formantEnvelopeAtFreqV545.(origPts, newFreq).max(~formantPreservationMinAmpV545);
                    rawGain = (oldEnv / newEnv).clip(0.55, 1.65);
                    gain = 1.0 + ((rawGain - 1.0) * rStrength);
                    newAmp = ((pt[2] ? 0.0).asFloat.max(0.0) * gain).clip(0.0, 1.0);
                    rPts[idx] = [pt[0], pt[1], newAmp, pt[3]] ++ if(pt.size > 4) { pt.copyRange(4, pt.size - 1) } { [] };
                };
            };
        };
        split[\harmonic].do { |idx| rPts[idx] = hPts[idx] };
        rPts = ~energyCompensateFrameV546.(origPts, rPts, split[\harmonic], hStrength);
        rPts = ~energyCompensateFrameV546.(origPts, rPts, split[\residual], rStrength);
        rPts
    }
};

~phaseLockedVocoderTracksV546 = { |tracks, frameDur, f0History = nil, transientFlags = nil|
    var nFrames, out, twoPi;
    if(~phaseLockedVocoderV546.not or: { tracks.isNil } or: { tracks.isEmpty }) {
        tracks
    } {
        twoPi = 6.283185307179586;
        nFrames = tracks[0][\points].size;
        out = ~copyTracksDeepV546.(tracks);
        nFrames.do { |frameIdx|
            var pts, leaderIdx, maxAmp, leaderPhase, leaderFreq, f0, transient;
            pts = out.collect { |tr| tr[\points][frameIdx] };
            maxAmp = 0.0;
            leaderIdx = nil;
            pts.do { |pt, idx|
                var amp;
                if(pt.notNil) {
                    amp = (pt[2] ? 0.0).asFloat.max(0.0);
                    if(amp > maxAmp) { maxAmp = amp; leaderIdx = idx };
                };
            };
            f0 = if(f0History.notNil and: { frameIdx < f0History.size }) { f0History[frameIdx] } { nil };
            transient = if(transientFlags.notNil and: { frameIdx < transientFlags.size }) { transientFlags[frameIdx] } { false };
            if(leaderIdx.notNil and: { maxAmp > ~phaseLockMinAmpV546 } and: { transient.not }) {
                leaderPhase = pts[leaderIdx][3] ? 0.0;
                leaderFreq = (pts[leaderIdx][1] ? 0.0).asFloat.max(1.0);
                pts.do { |pt, idx|
                    var freq, amp, centsToLeader, ratio, targetPhase, mix, newPhase;
                    if(pt.notNil and: { idx != leaderIdx }) {
                        freq = (pt[1] ? 0.0).asFloat.max(1.0);
                        amp = (pt[2] ? 0.0).asFloat.max(0.0);
                        if(amp > ~phaseLockMinAmpV546) {
                            ratio = (freq / leaderFreq).round.asInteger.max(1);
                            centsToLeader = ~centsDiffV544.(freq, leaderFreq * ratio);
                            if(centsToLeader < 65.0) {
                                targetPhase = leaderPhase * ratio;
                                mix = (0.18 * (amp / maxAmp.max(1e-12)).sqrt).clip(0.0, 0.32);
                                newPhase = pt[3] + ((targetPhase - pt[3]) * mix);
                                out[idx][\points][frameIdx] = [pt[0], pt[1], pt[2], newPhase]
                                    ++ if(pt.size > 4) { pt.copyRange(4, pt.size - 1) } { [] };
                            };
                        };
                    };
                };
            };
        };
        out
    }
};

~advancedSpectralProcessV546 = { |tracks, meta = nil|
    var out, nFrames, f0History, transientFlags, lastF0, formantHistory;
    if(tracks.isNil or: { tracks.isEmpty }) {
        tracks
    } {
        nFrames = tracks[0][\points].size;
        out = ~copyTracksDeepV546.(tracks);
        transientFlags = if(~transientProtectionV546) { ~transientMapV546.(out) } { Array.fill(nFrames, false) };
        formantHistory = if(~formantTrackingV547) { ~trackFormantsV548.(out, meta) } { nil };
        f0History = Array.newClear(nFrames);
        lastF0 = nil;
        nFrames.do { |frameIdx|
            var pts, est, f0, conf, smoothF0, lockedPts, transient, strengthNow;
            pts = out.collect { |tr| tr[\points][frameIdx] };
            transient = transientFlags[frameIdx] ? false;
            est = ~estimateF0FromFrameV544.(pts, ~harmonicLockF0MinV544, ~harmonicLockF0MaxV544);
            f0 = est[\f0];
            conf = est[\confidence] ? 0.0;
            if(f0.notNil and: { conf > 0.0001 }) {
                smoothF0 = if(lastF0.notNil and: { ~centsDiffV544.(f0, lastF0) < 120.0 }) {
                    (lastF0 * 0.86) + (f0 * 0.14)
                } { f0 };
                lastF0 = smoothF0;
                f0History[frameIdx] = smoothF0;
                strengthNow = if(transient and: { ~transientProtectionV546 }) { ~harmonicLockStrengthV544 * 0.18 } { ~harmonicLockStrengthV544 };
                lockedPts = if(~harmonicLockingV544) { ~harmonicLockFrameV544.(pts, smoothF0, strengthNow, ~harmonicLockCentsV544) } { pts };
                if(formantHistory.notNil) {
                    lockedPts = ~applyFormantTrackingFrameV548.(pts, lockedPts, formantHistory[frameIdx], transient);
                };
                lockedPts = ~applyEnvelopeSeparationFrameV546.(pts, lockedPts, smoothF0, transient);
                out.size.do { |trackIdx| out[trackIdx][\points][frameIdx] = lockedPts[trackIdx] };
            } {
                f0History[frameIdx] = lastF0;
            };
        };
        if(meta.notNil) {
            meta[\harmonicLockF0] = f0History;
            meta[\transientFlagsV546] = transientFlags;
            meta[\envelopeSeparationV546] = ~envelopeSeparationV546;
            meta[\phaseLockedVocoderV546] = ~phaseLockedVocoderV546;
            meta[\formantTrackingV548] = ~formantTrackingV548;
        };
        out = ~phaseLockedVocoderTracksV546.(out, 0.01, f0History, transientFlags);
        out
    }
};


~formantTrackingV548 = true;
~formantTrackCountV548 = 5;
~formantTrackMinFreqV548 = 180.0;
~formantTrackMaxFreqV548 = 8500.0;
~formantTrackSmoothV548 = 0.12;
~formantTrackGainSmoothV548 = 0.24;
~formantTrackBwSmoothV548 = 0.20;
~formantTrackStrengthV548 = 0.55;
~formantTrackMinAmpV548 = 1e-6;
~formantTrackMaxJumpOctV548 = 0.42;
~formantTrackMinConfidenceV548 = 0.10;
~formantTrackDefaultBwRatioV548 = 0.11;
~formantTrackMinBandwidthHzV548 = 70.0;
~formantTrackMaxBandwidthHzV548 = 1800.0;


~formantInertiaV548 = true;
~formantVelocityDampV548 = 0.72;
~formantMaxJumpOctV548 = 0.18;


~formantSlotBoundsV548 = [
    [180.0, 900.0],
    [550.0, 2800.0],
    [1500.0, 3600.0],
    [2500.0, 4500.0],
    [3200.0, 8500.0]
];
~formantSlotBoundStrengthV548 = 0.88;


~formantEnvBinsV548 = 64;
~formantEnvBwOctV548 = 0.28;
~formantEnvMinFreqV548 = 150.0;
~formantEnvMaxFreqV548 = 8500.0;


~formantTrackingV547 = ~formantTrackingV548;
~formantTrackCountV547 = ~formantTrackCountV548;
~formantTrackStrengthV547 = ~formantTrackStrengthV548;

~emptyFormantStateV548 = { |idx|
    (
        id: idx,
        freq: 0.0,
        gain: 0.0,
        bw: ~formantTrackMinBandwidthHzV548,
        confidence: 0.0,
        age: 0,
        misses: 999
    )
};

~buildFormantEnvelopeV548 = { |pts|
    var bins, logLo, logHi, logStep, env, bw2, result;
    bins = ~formantEnvBinsV548.asInteger.max(8);
    logLo = ~formantEnvMinFreqV548.max(20.0).log2;
    logHi = ~formantEnvMaxFreqV548.max(~formantEnvMinFreqV548 + 10.0).log2;
    logStep = (logHi - logLo) / (bins - 1).asFloat.max(1.0);
    env = FloatArray.newClear(bins);
    bw2 = ((~formantEnvBwOctV548.max(0.02)) ** 2) * 2.0;
    pts.do { |pt|
        var freq, amp, logF;
        if(pt.notNil) {
            freq = (pt[1] ? 0.0).asFloat.max(0.0);
            amp = (pt[2] ? 0.0).asFloat.max(0.0);
            if(freq >= ~formantEnvMinFreqV548 and: { freq <= ~formantEnvMaxFreqV548 } and: { amp > 1e-9 }) {
                logF = freq.log2;
                bins.do { |binIdx|
                    var binLog, dist;
                    binLog = logLo + (binIdx * logStep);
                    dist = logF - binLog;
                    env[binIdx] = env[binIdx] + (amp * exp((dist * dist).neg / bw2));
                };
            };
        };
    };
    result = Array.fill(bins, { |binIdx|
        (freq: 2.0 ** (logLo + (binIdx * logStep)), amp: env[binIdx], bin: binIdx)
    });
    result
};

~formantEnvelopePointsV548 = { |pts|

    ~buildFormantEnvelopeV548.(pts)
};

~estimateDetectedFormantBandwidthV548 = { |detected, idx|
    var cur, leftFreq, rightFreq, halfGap, bw;
    cur = detected[idx];
    if(cur.isNil) {
        ~formantTrackMinBandwidthHzV548
    } {
        leftFreq = if(idx > 0 and: { detected[idx - 1].notNil }) { detected[idx - 1][\freq] } { cur[\freq] * 0.72 };
        rightFreq = if(idx < (detected.size - 1) and: { detected[idx + 1].notNil }) { detected[idx + 1][\freq] } { cur[\freq] * 1.38 };
        halfGap = ((rightFreq - leftFreq).abs * 0.5).max(cur[\freq] * ~formantTrackDefaultBwRatioV548);
        bw = halfGap.clip(~formantTrackMinBandwidthHzV548, ~formantTrackMaxBandwidthHzV548);
        bw
    }
};

~detectFormantsFrameV548 = { |pts, count = 5|
    var env, peaks, selected, final;
    env = ~buildFormantEnvelopeV548.(pts);
    peaks = Array.new;
    if(env.size > 2) {
        (1 .. (env.size - 2)).do { |idx|
            var prev, cur, next, denom, off, refFreq, logStep, score;
            prev = env[idx - 1][\amp];
            cur = env[idx][\amp];
            next = env[idx + 1][\amp];
            if(cur > prev and: { cur >= next } and: { cur > 1e-12 }) {
                denom = prev - (2.0 * cur) + next;
                off = if(denom.abs > 1e-14) { (0.5 * (prev - next) / denom).clip(-0.5, 0.5) } { 0.0 };
                logStep = (~formantEnvMaxFreqV548.log2 - ~formantEnvMinFreqV548.log2) / (~formantEnvBinsV548 - 1).asFloat.max(1.0);
                refFreq = 2.0 ** (env[idx][\freq].log2 + (off * logStep));
                score = cur;
                peaks = peaks.add((freq: refFreq.max(20.0), gain: cur, score: score, confidence: 0.35));
            };
        };
    };
    if(peaks.isEmpty) {
        peaks = env.sort { |a, b| a[\amp] > b[\amp] }.copyRange(0, (count - 1).min(env.size - 1)).collect { |ev|
            (freq: ev[\freq], gain: ev[\amp], score: ev[\amp], confidence: 0.22)
        };
    };
    selected = peaks.sort { |a, b| a[\score] > b[\score] }.copyRange(0, (count - 1).min(peaks.size - 1));
    selected = selected.sort { |a, b| a[\freq] < b[\freq] };
    final = selected.collect { |fm, idx|
        fm.copy.put(\bw, ~estimateDetectedFormantBandwidthV548.(selected, idx))
    };
    final
};
)
