1138 lines
56 KiB
C#
1138 lines
56 KiB
C#
// 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);
|
|
}
|
|
}
|