// Exit codes: 0 = clean exit / parent ended; 2 = no render endpoint; // 3 = instance already running; 4 = WASAPI initialization failed; // 5 = unhandled exception / persistent capture error; // 6 = lease expired (Godot is not responding). using System; using System.Collections.Generic; using System.Diagnostics; using System.Globalization; using System.IO; using System.Net; using System.Net.Sockets; using System.Runtime.InteropServices; using System.Text; using System.Threading; namespace LoopbackCapture { // Independent analysis branch: never writes to RMS/onset/BPM detector state. sealed class RuleGenreAnalyzer { // TUNING TABLE: initial heuristics, NOT calibrated probabilities. Adjust here. const int FftSize = 2048, ShortHops = 400, RhythmHops = 1600; const int DynamicsSamples = 160, DynamicsHopCount = 10, MinDynamicsSamples = 40; const int MinBars = 4, MinPeaks = 4; const double FeatureAlpha = 0.05, Temperature = 0.20, ConfidenceThreshold = 0.30; const double BandMinHz = 100, BandMaxHz = 8000, HighHz = 2000; const double LowMinHz = 40, LowMaxHz = 120, MidMinHz = 200, MidMaxHz = 5000; const double CentroidMinHz = 500, CentroidMaxHz = 4000; const double FlatnessMin = 0.02, FlatnessMax = 0.50; const double HighRatioMin = 0.05, HighRatioMax = 0.60, LowRatioMin = 0.05, LowRatioMax = 0.50; const double DensityMax = 8, DynamicsMinDb = 6, DynamicsMaxDb = 24; const double LatinMinBpm = 85, LatinMaxBpm = 105, ElectronicMinBpm = 115, ElectronicMaxBpm = 135; const double HipHopMinBpm = 80, HipHopMaxBpm = 95, TempoShoulderBpm = 15; // Il dembow e' una firma discreta, non un contributo lineare: sopra soglia sposta // la decisione, sotto soglia non tocca nulla. Richiede anche affinita' di tempo // >= 0.5, altrimenti una sincope qualsiasi a 130 BPM verrebbe promossa a latin. // La soglia lavora sul dembow NORMALIZZATO (vedi DembowBaseline). const double DembowGate = 0.40, DembowBonus = 0.35; // Un istogramma uniforme correla gia' 7/16 con un template che ha 7 caselle attive // su 16. Senza togliere questo pavimento, qualsiasi ritmo piatto (rock con piatti // ovunque) ottiene ~0.44 e passa per un dembow debole. const double DembowBaseline = 7.0 / 16.0; // Il rilevatore puo' agganciare la cella 3+3+2 e riportare 4/3 del battito. // Si prova anche l'ipotesi 3/4 e si tiene quella che spiega meglio il pattern. const double FoldMargin = 0.05, MinFoldBpm = 50; static readonly double[] FoldFactors = { 1.0, 0.75, 1.25 }; const double RegularityCenter = 0.50, RegularityWidth = 0.50; const double PeakSigma = 1, PowerEpsilon = 1e-20, RmsFloor = 1e-6, ActiveRms = 1e-5; const int PublishMs = 1000, StaleMs = 1000; // Columns: dembow, fourFloor, tempo affinity, low, flatness, high, density, // centroid, regularity, medium regularity, dynamics. Negative = inhibitory. // Each row has total absolute weight 1; Bias implements rewarded complements. // Scores include Bias, then stable softmax(score / Temperature). static readonly string[] Labels = { "latin", "electronic", "hiphop", "rock", "classical" }; // Pesi derivati dalla distanza di Fisher misurata su dati reali etichettati // (tests\rock2.csv, classic.csv, hiphop.csv). Le feature sono quasi ortogonali: // flatness/highRatio separano classical da {rock, hiphop} ma NON rock da hiphop (d'~0.03); // regularity/regMid/dynamics separano rock da hiphop ma non rock da classical. // density non discrimina nessuna delle tre coppie (d' 0.14-0.45): peso azzerato. // I Bias NON sono scelti a mano: sono il valore che porta ogni classe a 0 sulla media // globale delle feature (bias_c = -w_c . mean). Senza questa compensazione una classe // diventa il "vincitore per default" e ogni ritaratura sposta il problema su un'altra. static readonly double[] Bias = { -0.273, -0.119, -0.197, 0.018, 0.191 }; static readonly double[,] Weights = { { 0.50, 0, 0.25, 0.25, 0, 0, 0, 0, 0, 0, 0 }, { 0, 0.35, 0.25, 0.15, 0, 0, 0, 0, 0.25, 0, 0 }, { 0, 0, 0, 0.15, 0, 0, 0, 0, 0.20, 0.35, 0.30 }, { 0, 0, 0, 0, 0.25, 0.15, 0, 0, -0.20, -0.25, -0.15 }, { 0, 0, 0, 0, -0.40, -0.45, 0, 0, 0, 0, 0.15 } }; static readonly int[] DembowTemplate = { 1,0,0,1,0,0,1,0,1,0,0,1,0,0,1,0 }; readonly int rate, hop; readonly double[] samples = new double[FftSize], hann = new double[FftSize]; readonly double[] real = new double[FftSize], imag = new double[FftSize]; readonly double[] cos = new double[FftSize / 2], sin = new double[FftSize / 2]; readonly int[] reverse = new int[FftSize]; readonly double[] previousPower = new double[FftSize / 2 + 1]; readonly double[] shortOnset = new double[ShortHops], rhythm = new double[RhythmHops]; readonly double[] envelope = new double[ShortHops], folded = new double[16]; readonly double[] dynamics = new double[DynamicsSamples], sortedDynamics = new double[DynamicsSamples]; readonly double[] features = new double[11], probabilities = new double[5]; int write, filled, hopFrames, shortHead, shortCount, rhythmHead, rhythmCount; int dynamicsHead, dynamicsCount, dynamicsHops, dynamicsFrames; double dynamicsSum, recentRms, centroid, flatness, highRatio, lowRatio; double dembow, fourFloor, density, regularity, dynamicRange; bool spectrumReady, dynamicReady; long lastDataMs = -1, lastPublishMs; StreamWriter dump; public double DembowPhase { get; private set; } // Tempo effettivamente usato per il folding: puo' essere i 3/4 di quello rilevato // se il pattern dimostra che il detector ha agganciato la cella 3+3+2. public double EffectiveBpm { get; private set; } public RuleGenreAnalyzer(int sampleRate, int hopSize, string dumpPath) { rate = sampleRate; hop = hopSize; for (int i = 0; i < FftSize; i++) { hann[i] = 0.5 - 0.5 * Math.Cos(2 * Math.PI * i / (FftSize - 1)); int x = i, r = 0; for (int b = 0; b < 11; b++) { r = (r << 1) | (x & 1); x >>= 1; } reverse[i] = r; } for (int i = 0; i < cos.Length; i++) { cos[i] = Math.Cos(-2 * Math.PI * i / FftSize); sin[i] = Math.Sin(-2 * Math.PI * i / FftSize); } if (!string.IsNullOrEmpty(dumpPath)) { try { dump = new StreamWriter(dumpPath, false, Encoding.UTF8); dump.WriteLine("ms,bpm,dembow,fourfloor,density,flatness,centroid,regularity,highRatio,lowRatio,label,conf,f0_latin_dembow,f1_fourfloor,f2_tempo_latin,f3_low,f4_flat,f5_high,f6_density,f7_centroid,f8_reg,f9_regmid,f10_dyn,s_latin,s_electronic,s_hiphop,s_rock,s_classical"); dump.Flush(); } catch (Exception ex) { DisableDump(ex); } } } void DisableDump(Exception ex) { Console.Error.WriteLine("Feature dump disabled: " + ex.Message); if (dump != null) { try { dump.Dispose(); } catch { } dump = null; } } public void MarkData(long now) { lastDataMs = now; } // Il folding ritmico dipende dal tempo: se il BPM cambia (nuovo brano), la storia // gia' registrata e' su una griglia che non corrisponde piu'. Va scartata, altrimenti // per fino a 16 s si pubblica un dembow/fourFloor casuale. public void ResetRhythm() { rhythmHead = 0; rhythmCount = 0; Array.Clear(rhythm, 0, rhythm.Length); dembow = 0; fourFloor = 0; DembowPhase = 0; } // Errore di ottava del rilevatore: 85 BPM puo' uscire 170, 195 puo' uscire 97.5. // Riporta il tempo in [70,145) prima di applicare sia i template di tempo sia il // folding ritmico. Senza questa normalizzazione nessuna regola di tempo entra in // gioco (LatinMin 85, HipHopMin 80) e vince sempre la classe senza termine ritmico. public static double CanonicalTempo(double bpm) { if (bpm <= 0) return 0; while (bpm >= 145.0) bpm /= 2.0; while (bpm < 70.0) bpm *= 2.0; return bpm; } public void AddSample(float value) { double v = float.IsNaN(value) || float.IsInfinity(value) ? 0 : value; samples[write] = v; write = (write + 1) % FftSize; if (filled < FftSize) filled++; dynamicsSum += v * v; dynamicsFrames++; if (++hopFrames < hop) return; hopFrames = 0; double flux = filled == FftSize ? Spectrum() : 0; shortOnset[shortHead] = flux; shortHead = (shortHead + 1) % ShortHops; shortCount = Math.Min(shortCount + 1, ShortHops); rhythm[rhythmHead] = flux; rhythmHead = (rhythmHead + 1) % RhythmHops; rhythmCount = Math.Min(rhythmCount + 1, RhythmHops); if (++dynamicsHops >= DynamicsHopCount) { recentRms = Math.Sqrt(dynamicsSum / Math.Max(1, dynamicsFrames)); dynamics[dynamicsHead] = 20 * Math.Log10(Math.Max(RmsFloor, recentRms)); dynamicsHead = (dynamicsHead + 1) % DynamicsSamples; dynamicsCount = Math.Min(dynamicsCount + 1, DynamicsSamples); dynamicsSum = 0; dynamicsFrames = 0; dynamicsHops = 0; } } // Real input, radix-2 complex workspace; only nonnegative frequency bins used. // All FFT/window/twiddle/history arrays are preallocated and reused per hop. double Spectrum() { for (int i = 0; i < FftSize; i++) { real[reverse[i]] = samples[(write + i) % FftSize] * hann[i]; imag[reverse[i]] = 0; } for (int size = 2; size <= FftSize; size <<= 1) { int half = size / 2, stride = FftSize / size; for (int start = 0; start < FftSize; start += size) for (int j = 0; j < half; j++) { int a = start + j, b = a + half, t = j * stride; double tr = cos[t] * real[b] - sin[t] * imag[b]; double ti = sin[t] * real[b] + cos[t] * imag[b]; real[b] = real[a] - tr; imag[b] = imag[a] - ti; real[a] += tr; imag[a] += ti; } } double total = 0, band = 0, weighted = 0, logs = 0, high = 0, low = 0, flux = 0; int bins = 0; for (int k = 0; k <= FftSize / 2; k++) { double hz = k * (double)rate / FftSize; double p = (real[k] * real[k] + imag[k] * imag[k]) / (FftSize * (double)FftSize); // One-sided power: DC/Nyquist occur once, other bins twice. if (k > 0 && k < FftSize / 2) p *= 2; total += p; if (hz >= BandMinHz && hz <= BandMaxHz) { band += p; weighted += hz * p; logs += Math.Log(Math.Max(PowerEpsilon, p)); bins++; } if (hz > HighHz) high += p; if (hz >= LowMinHz && hz <= LowMaxHz) low += p; if (hz >= MidMinHz && hz <= MidMaxHz && spectrumReady) flux += Math.Max(0, p - previousPower[k]); previousPower[k] = p; } double smoothing = spectrumReady ? FeatureAlpha : 1; centroid += smoothing * ((band > PowerEpsilon ? weighted / band : 0) - centroid); flatness += smoothing * ((band > PowerEpsilon && bins > 0 ? Clamp(Math.Exp(logs / bins) / (band / bins)) : 0) - flatness); highRatio += smoothing * ((total > PowerEpsilon ? high / total : 0) - highRatio); lowRatio += smoothing * ((total > PowerEpsilon ? low / total : 0) - lowRatio); spectrumReady = true; return flux; } static double Clamp(double x) { return Math.Max(0, Math.Min(1, x)); } static double Normalize(double x, double min, double max) { return Clamp((x - min) / (max - min)); } static double Tempo(double bpm, double min, double max) { return bpm <= 0 ? 0 : Clamp(1 - Math.Max(min - bpm, Math.Max(0, bpm - max)) / TempoShoulderBpm); } void RhythmFeatures(double bpm) { double maximum = PowerEpsilon; for (int i = 0; i < shortCount; i++) { envelope[i] = shortOnset[(shortHead - shortCount + i + ShortHops) % ShortHops]; maximum = Math.Max(maximum, envelope[i]); } double mean = 0, variance = 0; for (int i = 0; i < shortCount; i++) { envelope[i] /= maximum; mean += envelope[i]; } mean /= Math.Max(1, shortCount); for (int i = 0; i < shortCount; i++) variance += (envelope[i] - mean) * (envelope[i] - mean); double threshold = mean + PeakSigma * Math.Sqrt(variance / Math.Max(1, shortCount)); int peaks = 0, lastPeak = -1, intervals = 0; double sum = 0, squares = 0; for (int i = 1; i < shortCount - 1; i++) if (envelope[i] > threshold && envelope[i] > envelope[i - 1] && envelope[i] >= envelope[i + 1]) { peaks++; if (lastPeak >= 0) { double d = i - lastPeak; sum += d; squares += d * d; intervals++; } lastPeak = i; } // Available duration during warm-up; exactly 4 s once the 400-slot ring is full. density = peaks / Math.Max(0.01, shortCount / 100.0); regularity = peaks < MinPeaks ? 0 : 1 - Clamp(Math.Sqrt(Math.Max(0, squares / intervals - Math.Pow(sum / intervals, 2))) / (sum / intervals)); dembow = 0; fourFloor = 0; DembowPhase = 0; EffectiveBpm = 0; if (bpm <= 0) return; // Il pattern 3+3+2 crea periodicita' spurie a 4/3 e a 5/4 del battito: il // detector puo' agganciare una cella invece del battito (95 BPM letti 127 o 76). // Non lo si decide a priori: vince l'ipotesi che correla meglio col template. double bestD = 0, bestF = 0, bestP = 0, bestT = 0; bool found = false; for (int h = 0; h < FoldFactors.Length; h++) { double d, f, p; if (!Fold(bpm * FoldFactors[h], out d, out f, out p)) continue; if (!found || d > bestD + FoldMargin) { bestD = d; bestF = f; bestP = p; bestT = bpm * FoldFactors[h]; found = true; } } if (found) { dembow = bestD; fourFloor = bestF; DembowPhase = bestP; EffectiveBpm = bestT; } } bool Fold(double bpm, out double dembowScore, out double fourFloorScore, out double phaseScore) { dembowScore = 0; fourFloorScore = 0; phaseScore = 0; if (bpm < MinFoldBpm) return false; double hopPerBeat = 60 / bpm * 100, barHops = hopPerBeat * 4; int bars = (int)Math.Floor(rhythmCount / barHops); if (bars < MinBars) return false; int count = (int)Math.Floor(bars * barHops); Array.Clear(folded, 0, folded.Length); double maximum = PowerEpsilon; for (int i = 0; i < count; i++) maximum = Math.Max(maximum, rhythm[(rhythmHead - count + i + RhythmHops) % RhythmHops]); for (int i = 0; i < count; i++) folded[((int)Math.Floor(i / hopPerBeat * 4)) % 16] += rhythm[(rhythmHead - count + i + RhythmHops) % RhythmHops] / maximum / bars; double sum = 0; for (int i = 0; i < 16; i++) sum += folded[i]; if (sum <= PowerEpsilon) return false; for (int i = 0; i < 16; i++) folded[i] /= sum; for (int phase = 0; phase < 16; phase++) { double correlation = 0; for (int i = 0; i < 16; i++) correlation += folded[(i + phase) % 16] * DembowTemplate[i]; // Unit-sum folded envelope, binary template: theoretical maximum dot = 1. if (correlation > dembowScore) { dembowScore = Clamp(correlation); phaseScore = phase / 16.0; } double mass = 0, weakest = 1; for (int q = 0; q < 4; q++) { double v = folded[(phase + 4 * q) % 16]; mass += v; weakest = Math.Min(weakest, v); } // quarterMass * (weakest / meanQuarter): penalizes missing quarters. // Uniform 16 bins => .25; four equal quarter hits => 1; missing hit => 0. double floor = mass > 0 ? mass * Clamp(weakest / (mass / 4)) : 0; fourFloorScore = Math.Max(fourFloorScore, Clamp(floor)); } // Rimuove il pavimento del 7/16: 0 = nessuna informazione ritmica, 1 = dembow pieno. dembowScore = Clamp((dembowScore - DembowBaseline) / (1 - DembowBaseline)); return true; } double Percentile(double fraction) { double index = (dynamicsCount - 1) * fraction; int lo = (int)index, hi = Math.Min(lo + 1, dynamicsCount - 1); return sortedDynamics[lo] + (sortedDynamics[hi] - sortedDynamics[lo]) * (index - lo); } public void Publish(long now, double bpm, UdpClient udp, IPEndPoint destination) { if (now - lastPublishMs < PublishMs) return; lastPublishMs = now; bool fresh = lastDataMs >= 0 && now - lastDataMs <= StaleMs; RhythmFeatures(bpm); // Il termine di tempo usa il BPM che ha vinto il confronto di folding, // non quello grezzo del rilevatore. double tempo = EffectiveBpm > 0 ? EffectiveBpm : bpm; dynamicReady = dynamicsCount >= MinDynamicsSamples; dynamicRange = 0; if (dynamicReady) { Array.Copy(dynamics, sortedDynamics, dynamicsCount); Array.Sort(sortedDynamics, 0, dynamicsCount); dynamicRange = Percentile(0.90) - Percentile(0.10); } features[0] = dembow; features[1] = fourFloor; features[3] = Normalize(lowRatio, LowRatioMin, LowRatioMax); features[4] = Normalize(flatness, FlatnessMin, FlatnessMax); features[5] = Normalize(highRatio, HighRatioMin, HighRatioMax); features[6] = Normalize(density, 0, DensityMax); features[7] = Normalize(centroid, CentroidMinHz, CentroidMaxHz); features[8] = regularity; features[9] = Clamp(1 - Math.Abs(regularity - RegularityCenter) / RegularityWidth); features[10] = dynamicReady ? Normalize(dynamicRange, DynamicsMinDb, DynamicsMaxDb) : 0; double maxScore = double.NegativeInfinity; double[] rawScores = new double[Labels.Length]; for (int c = 0; c < Labels.Length; c++) { features[2] = c == 0 ? Tempo(tempo, LatinMinBpm, LatinMaxBpm) : c == 1 ? Tempo(tempo, ElectronicMinBpm, ElectronicMaxBpm) : c == 2 ? Tempo(tempo, HipHopMinBpm, HipHopMaxBpm) : 0; double score = Bias[c]; for (int j = 0; j < features.Length; j++) score += features[j] * Weights[c, j]; // Dembow come soglia, non come peso: un pattern 3+3+2 riconosciuto vale // piu' di un contributo lineare, ma solo se il tempo e' compatibile. if (c == 0 && dembow >= DembowGate && Tempo(tempo, LatinMinBpm, LatinMaxBpm) >= 0.5) score += DembowBonus; probabilities[c] = score; rawScores[c] = score; maxScore = Math.Max(maxScore, score); } double total = 0; bool active = fresh && recentRms >= ActiveRms && shortCount >= ShortHops; for (int c = 0; c < Labels.Length; c++) { probabilities[c] = active ? Math.Exp((probabilities[c] - maxScore) / Temperature) : 1; total += probabilities[c]; } for (int c = 0; c < Labels.Length; c++) probabilities[c] /= total; int best = 0; for (int c = 1; c < Labels.Length; c++) if (probabilities[c] > probabilities[best]) best = c; string label = probabilities[best] < ConfidenceThreshold ? "unknown" : Labels[best]; StringBuilder packet = new StringBuilder(); packet.AppendFormat(CultureInfo.InvariantCulture, "GENR:1;{0};{1:F3}", label, probabilities[best]); for (int c = 0; c < Labels.Length; c++) packet.AppendFormat(CultureInfo.InvariantCulture, ";{0}={1:F3}", Labels[c], probabilities[c]); try { byte[] bytes = Encoding.UTF8.GetBytes(packet.ToString()); udp.Send(bytes, bytes.Length, destination); } catch { } if (dump != null) { try { StringBuilder row = new StringBuilder(); row.AppendFormat(CultureInfo.InvariantCulture, "{0},{1:F3},{2:F3},{3:F3},{4:F3},{5:F6},{6:F3},{7:F3},{8:F6},{9:F6},{10},{11:F3}", now, tempo, fresh ? dembow : 0, fresh ? fourFloor : 0, fresh ? density : 0, fresh ? flatness : 0, fresh ? centroid : 0, fresh ? regularity : 0, fresh ? highRatio : 0, fresh ? lowRatio : 0, label, probabilities[best]); // Valori normalizzati visti dal classificatore + punteggi grezzi per classe: // servono a capire QUALE termine fa perdere una classe, non solo che perde. for (int j = 0; j < features.Length; j++) row.AppendFormat(CultureInfo.InvariantCulture, ",{0:F3}", features[j]); for (int c = 0; c < Labels.Length; c++) row.AppendFormat(CultureInfo.InvariantCulture, ",{0:F3}", rawScores[c]); dump.WriteLine(row.ToString()); dump.Flush(); // Once a second, never on the per-frame path. } catch (Exception ex) { DisableDump(ex); } } } } class Program { const int SIO_UDP_CONNRESET = -1744830452; static int selectedTargetPid = 0; // 0 = Tutto il sistema static Mutex instanceMutex; static ManualResetEvent cmdReady = new ManualResetEvent(false); static long leaseDeadlineMs; static void Main(string[] args) { try { Run(args); } catch (Exception ex) { Console.Error.WriteLine(ex); Environment.Exit(5); } } static void Run(string[] args) { Stopwatch lifecycleClock = Stopwatch.StartNew(); int leaseMs = 0; string dumpPath = null; foreach (string arg in args) { if (arg.StartsWith("--dump-features=", StringComparison.Ordinal)) dumpPath = arg.Substring(16); if (arg.StartsWith("--lease-ms=", StringComparison.Ordinal)) { int parsedLease; if (int.TryParse(arg.Substring(11), out parsedLease) && parsedLease > 0) leaseMs = parsedLease; } } Interlocked.Exchange(ref leaseDeadlineMs, lifecycleClock.ElapsedMilliseconds + leaseMs); int port = 4242; int cmdPort = 4243; if (args.Length > 0) { int.TryParse(args[0], out port); cmdPort = port + 1; } int parentPid = 0; if (args.Length > 1) int.TryParse(args[1], out parentPid); if (parentPid > 0) { Thread parentWatchdog = new Thread(() => { try { using (Process parent = Process.GetProcessById(parentPid)) { parent.WaitForExit(); } } catch { } Environment.Exit(0); }); parentWatchdog.IsBackground = true; parentWatchdog.Start(); } bool createdNew; instanceMutex = new Mutex(false, "Local\\LoopbackCapture_" + port, out createdNew); if (!createdNew) { Console.Error.WriteLine("LoopbackCapture: istanza gia attiva sulla porta " + port); Environment.Exit(3); } GC.KeepAlive(instanceMutex); UdpClient udpSend = null; try { udpSend = new UdpClient(); byte[] inValue = new byte[] { 0, 0, 0, 0 }; byte[] outValue = new byte[] { 0, 0, 0, 0 }; udpSend.Client.IOControl(SIO_UDP_CONNRESET, inValue, outValue); } catch { } IPEndPoint remoteEp = new IPEndPoint(IPAddress.Loopback, port); // Listener comandi di selezione processo inviati da Godot Thread cmdListenerThread = new Thread(() => { UdpClient udpCmd = null; try { udpCmd = new UdpClient(cmdPort); cmdReady.Set(); IPEndPoint sender = new IPEndPoint(IPAddress.Any, 0); while (true) { byte[] bytes = udpCmd.Receive(ref sender); string cmd = Encoding.UTF8.GetString(bytes).Trim(); if (cmd.StartsWith("PID:")) { int pid; if (int.TryParse(cmd.Substring(4), out pid)) { selectedTargetPid = pid; } } else if (cmd.StartsWith("PING:", StringComparison.Ordinal)) { Interlocked.Exchange(ref leaseDeadlineMs, lifecycleClock.ElapsedMilliseconds + leaseMs); } // Unknown commands are deliberately ignored. } } catch { } }); cmdListenerThread.IsBackground = true; cmdListenerThread.Start(); // Thread.Start alone does not guarantee that the command socket is bound. if (!cmdReady.WaitOne(2000)) Console.Error.WriteLine("LoopbackCapture: command socket not ready after 2000 ms; continuing."); // Announce after command readiness (or its bounded diagnostic timeout). try { byte[] hello = Encoding.UTF8.GetBytes("HELLO:2"); udpSend.Send(hello, hello.Length, remoteEp); } catch { } IMMDeviceEnumerator enumerator = (IMMDeviceEnumerator)new MMDeviceEnumeratorComObject(); IMMDevice device = null; int hr = enumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eMultimedia, out device); if (hr != 0 || device == null) { hr = enumerator.GetDefaultAudioEndpoint(EDataFlow.eRender, ERole.eConsole, out device); if (hr != 0 || device == null) Environment.Exit(2); } Guid iidMgr = typeof(IAudioSessionManager2).GUID; object oMgr; hr = device.Activate(ref iidMgr, 1, IntPtr.Zero, out oMgr); if (hr != 0 || oMgr == null) Environment.Exit(4); IAudioSessionManager2 sessionManager = (IAudioSessionManager2)oMgr; Guid iidAudioClient = typeof(IAudioClient).GUID; object oAudioClient; hr = device.Activate(ref iidAudioClient, 1, IntPtr.Zero, out oAudioClient); if (hr != 0 || oAudioClient == null) Environment.Exit(4); IAudioClient audioClient = (IAudioClient)oAudioClient; IntPtr pMixFormat; hr = audioClient.GetMixFormat(out pMixFormat); if (hr != 0 || pMixFormat == IntPtr.Zero) Environment.Exit(4); WAVEFORMATEX wf = (WAVEFORMATEX)Marshal.PtrToStructure(pMixFormat, typeof(WAVEFORMATEX)); int channels = wf.nChannels; int bitsPerSample = wf.wBitsPerSample; int sampleRate = wf.nSamplesPerSec > 0 ? wf.nSamplesPerSec : 48000; bool isFloat = (wf.wFormatTag == 3); if (wf.wFormatTag == -2) { WAVEFORMATEXTENSIBLE wfe = (WAVEFORMATEXTENSIBLE)Marshal.PtrToStructure(pMixFormat, typeof(WAVEFORMATEXTENSIBLE)); if (wfe.SubFormat == new Guid("00000003-0000-0010-8000-00aa00389b71")) isFloat = true; } if (bitsPerSample == 32 && !isFloat) { byte[] raw = new byte[40]; Marshal.Copy(pMixFormat, raw, 0, 40); if (raw[24] == 3) isFloat = true; } const int AUDCLNT_STREAMFLAGS_LOOPBACK = 0x00020000; const int AUDCLNT_SHAREMODE_SHARED = 0; Guid emptySession = Guid.Empty; hr = audioClient.Initialize(AUDCLNT_SHAREMODE_SHARED, AUDCLNT_STREAMFLAGS_LOOPBACK, 10000000, 0, pMixFormat, ref emptySession); if (hr != 0) Environment.Exit(4); Guid iidCaptureClient = typeof(IAudioCaptureClient).GUID; object oCaptureClient; hr = audioClient.GetService(ref iidCaptureClient, out oCaptureClient); if (hr != 0 || oCaptureClient == null) Environment.Exit(4); IAudioCaptureClient captureClient = (IAudioCaptureClient)oCaptureClient; hr = audioClient.Start(); if (hr != 0) Environment.Exit(4); // Filtro Passa-Basso sui Sub-Bassi (cassa e basse frequenze: 120 Hz) float cutoffFreq = 120.0f; float alpha = (float)(2.0 * Math.PI * cutoffFreq / sampleRate); alpha = Math.Max(0.003f, Math.Min(0.08f, alpha)); float lp1 = 0f; float lp2 = 0f; float currentTotalRms = 0f; // Buffer circolare onset flux temporizzato ai campioni audio reali (100 Hz = ogni 10ms esatti) int hopSize = sampleRate / 100; if (hopSize < 1) hopSize = 480; RuleGenreAnalyzer genreAnalyzer = new RuleGenreAnalyzer(sampleRate, hopSize, dumpPath); const int BUFFER_HOPS = 400; // 4.0 secondi di finestra temporale float[] onsetBuffer = new float[BUFFER_HOPS]; int onsetHead = 0; int totalHopsRecorded = 0; int hopFrameAccumulator = 0; double hopKickSumSq = 0; double hopTotalSumSq = 0; float prevHopKickRms = 0; float prevHopTotalRms = 0; float detectedBpm = 0.0f; double foldedBpm = 0.0; // tempo canonico con cui e' stato costruito lo storico ritmico int candidateBpm = 0; int candidateStreak = 0; int bpmEvalCounter = 0; long lastAppListBroadcast = 0; int myPid = Process.GetCurrentProcess().Id; long lastHeartbeat = -250; long heartbeatCounter = 0; long captureErrorSince = -1; while (true) { if (leaseMs > 0 && lifecycleClock.ElapsedMilliseconds > Interlocked.Read(ref leaseDeadlineMs)) { // Prefer clean parent termination even if its watchdog has not run yet. if (parentPid > 0) { try { using (Process parent = Process.GetProcessById(parentPid)) { if (parent.HasExited) Environment.Exit(0); } } catch { Environment.Exit(0); } } // A PING may have renewed the lease while checking the parent. if (lifecycleClock.ElapsedMilliseconds > Interlocked.Read(ref leaseDeadlineMs)) { Console.Error.WriteLine("LoopbackCapture: lease expired (Godot is not responding)."); Environment.Exit(6); } } if (lifecycleClock.ElapsedMilliseconds - lastHeartbeat >= 250) { lastHeartbeat = lifecycleClock.ElapsedMilliseconds; try { byte[] heartbeat = Encoding.UTF8.GetBytes(string.Format("HB:{0};0", heartbeatCounter++)); udpSend.Send(heartbeat, heartbeat.Length, remoteEp); } catch { } } // 1. Lettura campioni PCM WASAPI dal loopback di sistema uint packetLength = 0; hr = captureClient.GetNextPacketSize(out packetLength); while (packetLength > 0 && hr == 0) { IntPtr pData; uint numFramesRead; int flags; ulong devPos, qpcPos; hr = captureClient.GetBuffer(out pData, out numFramesRead, out flags, out devPos, out qpcPos); if (hr != 0) break; if (numFramesRead > 0) genreAnalyzer.MarkData(lifecycleClock.ElapsedMilliseconds); if ((flags & 1) == 0 && numFramesRead > 0) { double totalSumSq = 0; double kickSumSq = 0; int frames = (int)numFramesRead; unsafe { byte* ptr = (byte*)pData.ToPointer(); for (int f = 0; f < frames; f++) { float monoSample = 0f; if (isFloat && bitsPerSample == 32) { float* fptr = (float*)ptr + (f * channels); for (int c = 0; c < channels; c++) monoSample += fptr[c]; monoSample /= channels; } else if (!isFloat && bitsPerSample == 32) { int* iptr = (int*)ptr + (f * channels); for (int c = 0; c < channels; c++) monoSample += (iptr[c] / 2147483648.0f); monoSample /= channels; } else if (bitsPerSample == 16) { short* sptr = (short*)ptr + (f * channels); for (int c = 0; c < channels; c++) monoSample += (sptr[c] / 32768.0f); monoSample /= channels; } genreAnalyzer.AddSample((flags & 2) != 0 ? 0f : monoSample); totalSumSq += (monoSample * monoSample); // Filtro IIR passa-basso a doppio polo per estrarre la cassa lp1 += alpha * (monoSample - lp1); lp2 += alpha * (lp1 - lp2); kickSumSq += (lp2 * lp2); hopTotalSumSq += (monoSample * monoSample); hopKickSumSq += (lp2 * lp2); hopFrameAccumulator++; // Ogni 10ms esatti di campioni audio registrati dal clock DAC if (hopFrameAccumulator >= hopSize) { float hopKickRms = (float)Math.Sqrt(hopKickSumSq / hopSize); float hopTotalRms = (float)Math.Sqrt(hopTotalSumSq / hopSize); float kickFlux = Math.Max(0f, hopKickRms - prevHopKickRms); float totalFlux = Math.Max(0f, hopTotalRms - prevHopTotalRms); prevHopKickRms = hopKickRms; prevHopTotalRms = hopTotalRms; // L'onset combina la spinta del sub-basso (3.5x) e l'impatto a banda intera float onset = (kickFlux * 3.5f) + totalFlux; onsetBuffer[onsetHead] = onset; onsetHead = (onsetHead + 1) % BUFFER_HOPS; if (totalHopsRecorded < BUFFER_HOPS) totalHopsRecorded++; hopFrameAccumulator = 0; hopKickSumSq = 0; hopTotalSumSq = 0; } } } if (frames > 0) { float packetTotalRms = (float)Math.Sqrt(totalSumSq / frames); currentTotalRms = (currentTotalRms * 0.25f) + (packetTotalRms * 0.75f); } } else { for (uint f = 0; f < numFramesRead; f++) genreAnalyzer.AddSample(0f); currentTotalRms *= 0.7f; } captureClient.ReleaseBuffer(numFramesRead); hr = captureClient.GetNextPacketSize(out packetLength); } // A full second of consecutive failed capture iterations is persistent. if (hr != 0) { if (captureErrorSince < 0) captureErrorSince = lifecycleClock.ElapsedMilliseconds; if (lifecycleClock.ElapsedMilliseconds - captureErrorSince >= 1000) { Console.Error.WriteLine("Persistent WASAPI capture error: " + hr); Environment.Exit(5); } } else captureErrorSince = -1; // 2. Volume mirato se selezionata una specifica applicazione (es. Spotify/Chrome) float displayRms = currentTotalRms; if (selectedTargetPid > 0 && sessionManager != null) { try { IAudioSessionEnumerator sessionEnum; sessionManager.GetSessionEnumerator(out sessionEnum); int count; sessionEnum.GetCount(out count); for (int i = 0; i < count; i++) { object oSession; sessionEnum.GetSession(i, out oSession); var session2 = (IAudioSessionControl2)oSession; uint pid; session2.GetProcessId(out pid); if (pid == selectedTargetPid) { var meter = (IAudioMeterInformation)oSession; float peak = 0; meter.GetPeakValue(out peak); displayRms = peak; break; } } } catch { } } // 3. Autocorrelazione & Comb-Filter su spettro ritmico per rilevamento esatto del BPM bpmEvalCounter++; if (bpmEvalCounter >= 10) // Ogni ~80-100ms { bpmEvalCounter = 0; if (totalHopsRecorded >= 120) // Almeno 1.2 secondi di audio { // Srotola il buffer circolare e trova il valore massimo per normalizzare float[] env = new float[totalHopsRecorded]; float maxOnset = 0.0000001f; for (int i = 0; i < totalHopsRecorded; i++) { int idx = (onsetHead - totalHopsRecorded + i + BUFFER_HOPS) % BUFFER_HOPS; float val = onsetBuffer[idx]; env[i] = val; if (val > maxOnset) maxOnset = val; } // Se c'è un segnale ritmico (anche con volume Windows molto basso) if (maxOnset > 0.00002f) { // Normalizzazione: rende l'autocorrelazione totalmente indipendente dal volume di Windows! for (int i = 0; i < totalHopsRecorded; i++) { env[i] /= maxOnset; } double[] scores = new double[225]; double[] weights = new double[] { 1.0, 0.5, 0.25, 0.125 }; // Valuta tutti i possibili BPM da 70 a 215 for (int bpm = 70; bpm <= 215; bpm++) { double lag = (60.0 / bpm) * 100.0; // 100.0 Hz double score = 0; for (int h = 1; h <= 4; h++) { int l = (int)Math.Round(h * lag); if (l >= totalHopsRecorded) break; double weight = weights[h - 1]; double dot = 0; int count = 0; for (int i = l; i < totalHopsRecorded; i++) { dot += env[i] * env[i - l]; count++; } if (count > 0) score += weight * (dot / count); } scores[bpm] = score; } // Bias di stabilità: leggero bonus al tempo attivo per assorbire micro-fill di 0.2s if (detectedBpm > 50.0f) { for (int bpm = 70; bpm <= 215; bpm++) { float diff = Math.Abs(bpm - detectedBpm); if (diff <= 6.0f) { scores[bpm] *= (1.0 + 0.20 * (1.0 - diff / 6.0)); } } } int bestCandidateBpm = 70; double bestCandidateScore = 0; for (int bpm = 70; bpm <= 215; bpm++) { if (scores[bpm] > bestCandidateScore) { bestCandidateScore = scores[bpm]; bestCandidateBpm = bpm; } } // Risoluzione ottave: distingue brani lenti (90 BPM) da brani veloci (180-190 BPM). // Raddoppia solo se C'È EFFETTIVA energia percussiva al tempo veloce (rFast/rSlow >= 0.55), // evitando che i leggeri charleston a 1/8 di un pezzo a 90 BPM forzino il raddoppio a 180! if (bestCandidateBpm <= 105 && bestCandidateBpm * 2 <= 215) { int doubleBpm = bestCandidateBpm * 2; if (scores[doubleBpm] >= bestCandidateScore * 0.80) { int lagSlow = (int)Math.Round((60.0 / bestCandidateBpm) * 100.0); int lagFast = (int)Math.Round((60.0 / doubleBpm) * 100.0); double rSlow = 0, rFast = 0; int cSlow = 0, cFast = 0; for (int i = lagSlow; i < totalHopsRecorded; i++) { rSlow += env[i] * env[i - lagSlow]; cSlow++; } for (int i = lagFast; i < totalHopsRecorded; i++) { rFast += env[i] * env[i - lagFast]; cFast++; } if (cSlow > 0) rSlow /= cSlow; if (cFast > 0) rFast /= cFast; if (rFast >= rSlow * 0.55) { bestCandidateBpm = doubleBpm; } } } if (bestCandidateScore > 0.0005) { if (detectedBpm <= 10.0f) { // Primo aggancio immediato detectedBpm = bestCandidateBpm; candidateBpm = bestCandidateBpm; candidateStreak = 0; } else { float diff = Math.Abs(bestCandidateBpm - detectedBpm); if (diff <= 4.0f) { // Micro-fluttuazione naturale del brano: adatta dolcemente detectedBpm = (detectedBpm * 0.94f) + (bestCandidateBpm * 0.06f); candidateStreak = 0; } else { // Il candidato si discosta significativamente dal tempo attuale. // Per cambiare tempo (cambio canzone effettivo) deve rimanere stabile e confermato per almeno 10 cicli (~1 secondo)! if (Math.Abs(bestCandidateBpm - candidateBpm) <= 3) { candidateStreak++; if (candidateStreak >= 10) { detectedBpm = (detectedBpm * 0.4f) + (bestCandidateBpm * 0.6f); if (Math.Abs(detectedBpm - bestCandidateBpm) < 2.0f) { detectedBpm = bestCandidateBpm; candidateStreak = 0; } } } else { candidateBpm = bestCandidateBpm; candidateStreak = 1; } } } } } } } // Il folding ritmico e' valido solo sullo stesso brano. Il ring contiene envelope // di onset indipendenti dal tempo: il problema non e' il BPM in se', ma mediare // battute di brani diversi. Serve quindi un salto DISCRETO di tempo, non la deriva // dell'inseguimento morbido (0.94/0.06), che altrimenti azzererebbe lo storico // a ogni gradino e dembow resterebbe sempre a zero. // Il confronto usa il tempo canonico: un flip di ottava del rilevatore (170 -> 171) // non deve azzerare nulla, mentre un cambio reale di brano si'. double canonicalBpm = RuleGenreAnalyzer.CanonicalTempo(detectedBpm); if (detectedBpm > 50.0f && Math.Abs(canonicalBpm - foldedBpm) > 10.0) { genreAnalyzer.ResetRhythm(); } foldedBpm = canonicalBpm; genreAnalyzer.Publish(lifecycleClock.ElapsedMilliseconds, canonicalBpm, udpSend, remoteEp); // 4. Invio lista applicazioni attive (FILTRANDO se stesso e Godot!) long nowTicks = DateTime.UtcNow.Ticks; if ((nowTicks - lastAppListBroadcast) >= (TimeSpan.TicksPerMillisecond * 1500) && sessionManager != null) { lastAppListBroadcast = nowTicks; try { IAudioSessionEnumerator sessionEnum; sessionManager.GetSessionEnumerator(out sessionEnum); int count; sessionEnum.GetCount(out count); StringBuilder sb = new StringBuilder("APPS:0:Tutto il sistema"); for (int i = 0; i < count; i++) { object oSession; sessionEnum.GetSession(i, out oSession); var session2 = (IAudioSessionControl2)oSession; uint pid; session2.GetProcessId(out pid); if (pid > 0 && pid != myPid) { string name = ""; try { Process p = Process.GetProcessById((int)pid); name = p.ProcessName; string lowerName = name.ToLower(); // FILTRA: nasconde LoopbackCapture e Godot dal menu! if (lowerName.Contains("loopbackcapture") || lowerName.Contains("godot")) continue; } catch { } if (!string.IsNullOrEmpty(name)) { sb.AppendFormat(";{0}:{1}", pid, name); } } } byte[] appBytes = Encoding.UTF8.GetBytes(sb.ToString()); udpSend.Send(appBytes, appBytes.Length, remoteEp); } catch { } } // 5. Invio dati audio a Godot (8 byte: RMS + BPM) if (udpSend != null) { byte[] payload = new byte[8]; Array.Copy(BitConverter.GetBytes(displayRms), 0, payload, 0, 4); Array.Copy(BitConverter.GetBytes(detectedBpm), 0, payload, 4, 4); try { udpSend.Send(payload, payload.Length, remoteEp); } catch { } } Thread.Sleep(8); } } } [ComImport] [Guid("BCDE0395-E52F-467C-8E3D-C4579291692E")] class MMDeviceEnumeratorComObject { } public enum EDataFlow { eRender, eCapture, eAll } public enum ERole { eConsole, eMultimedia, eCommunications } [Guid("A95664D2-9614-4F35-A746-DE8DB63617E6"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IMMDeviceEnumerator { int EnumAudioEndpoints(EDataFlow dataFlow, int stateMask, out IntPtr devices); int GetDefaultAudioEndpoint(EDataFlow dataFlow, ERole role, out IMMDevice endpoint); int GetDevice(string id, out IMMDevice device); int RegisterEndpointNotificationCallback(IntPtr client); int UnregisterEndpointNotificationCallback(IntPtr client); } [Guid("D666063F-1587-4E43-81F1-B948E807363F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IMMDevice { int Activate(ref Guid id, int clsCtx, IntPtr activationParams, [MarshalAs(UnmanagedType.IUnknown)] out object interfacePointer); int OpenPropertyStore(int stgmAccess, out IntPtr properties); int GetId([MarshalAs(UnmanagedType.LPWStr)] out string id); int GetState(out int state); } [Guid("77AA99A0-1BD6-484F-8BC7-2C654C9A9B6F"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAudioSessionManager2 { int GetAudioSessionControl(IntPtr sessionId, int priority, out IntPtr control); int GetSimpleAudioVolume(IntPtr sessionId, int priority, out IntPtr volume); int GetSessionEnumerator(out IAudioSessionEnumerator sessionEnum); } [Guid("E2F5BB11-0570-40CA-ACDD-3AA01277DEE8"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAudioSessionEnumerator { int GetCount(out int sessionCount); int GetSession(int sessionIndex, [MarshalAs(UnmanagedType.IUnknown)] out object session); } [Guid("bfb7ff88-7239-4fc9-8fa2-07c950be9c6d"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAudioSessionControl2 { int GetState(out int state); int GetDisplayName(out IntPtr name); int SetDisplayName(string value, IntPtr eventContext); int GetIconPath(out IntPtr path); int SetIconPath(string value, IntPtr eventContext); int GetGroupingParam(out Guid grouping); int SetGroupingParam(ref Guid grouping, IntPtr eventContext); int RegisterAudioSessionNotification(IntPtr client); int UnregisterAudioSessionNotification(IntPtr client); int GetSessionIdentifier(out IntPtr id); int GetSessionInstanceIdentifier(out IntPtr id); int GetProcessId(out uint processId); int IsSystemSoundsSession(); int SetDuckingPreference(bool optOut); } [Guid("C02216F6-8C67-4B5B-9D00-D008E73E0064"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAudioMeterInformation { int GetPeakValue(out float peak); } [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct WAVEFORMATEX { public short wFormatTag; public short nChannels; public int nSamplesPerSec; public int nAvgBytesPerSec; public short nBlockAlign; public short wBitsPerSample; public short cbSize; } [StructLayout(LayoutKind.Sequential, Pack = 1)] public struct WAVEFORMATEXTENSIBLE { public WAVEFORMATEX Format; public short wValidBitsPerSample; public int dwChannelMask; public Guid SubFormat; } [Guid("1CB9AD4C-DBFA-4c32-B178-C2F568A703B2"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAudioClient { int Initialize(int shareMode, int streamFlags, long hnsBufferDuration, long hnsPeriodicity, IntPtr pFormat, ref Guid audioSessionGuid); int GetBufferSize(out uint bufferFrameCount); int GetStreamLatency(out long hnsLatency); int GetCurrentPadding(out uint numPaddingFrames); int IsFormatSupported(int shareMode, IntPtr pFormat, out IntPtr ppClosestMatch); int GetMixFormat(out IntPtr ppDeviceFormat); int GetDevicePeriod(out long hnsDefaultDevicePeriod, out long hnsMinimumDevicePeriod); int Start(); int Stop(); int Reset(); int SetEventHandle(IntPtr eventHandle); int GetService(ref Guid interfaceId, [MarshalAs(UnmanagedType.IUnknown)] out object interfacePointer); } [Guid("C8ADBD64-E71E-48a0-A4DE-185C395CD317"), InterfaceType(ComInterfaceType.InterfaceIsIUnknown)] public interface IAudioCaptureClient { int GetBuffer(out IntPtr dataPointer, out uint numFramesToRead, out int bufferFlags, out ulong devicePosition, out ulong qpcPosition); int ReleaseBuffer(uint numFramesRead); int GetNextPacketSize(out uint numFramesInNextPacket); } }