-| **59** görselleştirici modu | **43** arkaplan | **40** GPU efekti | **18** sahne geçişi |
+| **60** görselleştirici modu | **43** arkaplan | **40** GPU efekti | **18** sahne geçişi |
|:---:|:---:|:---:|:---:|
| **81** hazır sahne | **98** formül + **13** 3B katı cisim | **42** yerleşik GLSL shader | **58** renk paleti |
| **10.347** MilkDrop presetiyle sınandı | Yapay zekâ ajanları için **96** MCP aracı | **17** katman karışım kipi | **2** dil (TR / EN) |
@@ -288,7 +288,7 @@ paylaştığı bir BPM kilidiyle.
-**59 görselleştirici modunun hepsi**
+**60 görselleştirici modunun hepsi**

@@ -303,7 +303,7 @@ Bu iki pafta doğrudan mod kataloğundan üretiliyor; yeni bir mod, ekran görü
Her görselleştirici her arkaplanın üzerinde durabilir; katmanlarla her birinden istediğiniz kadar
üst üste koyabilirsiniz. v3.1.4'ten sonra eklenen modlar
3.1.5'in parçası.
-**Görselleştirici modları — 59**
+**Görselleştirici modları — 60**
- **Temel** — Barlar · Merkez · Segment (LED ekolayzer) · Nokta Matris · Şehir Silüeti (pencereleri
yanan binalar)
@@ -314,7 +314,8 @@ Her görselleştirici her arkaplanın üzerinde durabilir; katmanlarla her birin
(kutupsal gül eğrisi) · Kaleydoskop · Girdap · Helis · Tünel · Küre · Radar Grafiği
- **Parçacık ve olay** — Parçacık · Havai Fişek (vuruşta patlamalar) · Şimşek (basta dallanan
yıldırımlar) · Baloncuk · Sıvı Damla (metatoplar) · Dalgalı Izgara (vuruşta yayılan halkalar) ·
- Spektrogram · Konfeti · Vuruş Pedleri · Zıplayan Toplar
+ Spektrogram · Konfeti · Vuruş Pedleri · Zıplayan Toplar · Stereo İzler (her bant stereo görüntüdeki
+ yerinden fırlar)
- **Üretken sistemler** — Akış Alanı (gürültü alanının yönlendirdiği parçacıklar) · Sürü (tayfın sürdüğü
boid'ler) · Voronoi · Truchet · Moiré · Dalga Girişimi · İpler (vuruşlarla itilen verlet fiziği) ·
Galaksi · DNA Sarmalı · İzometrik Şehir · Çekici Alanı (formül kitaplığından iki parametresi sese
@@ -727,9 +728,49 @@ eşleyin — MilkDrop'un sonraki, önceki, rastgele, kes, kilit ve puan eylemler
**OSC.** Elle yazılmış bir OSC 1.0 ayrıştırıcılı UDP dinleyici; TouchOSC, Resolume, Ableton ya da QLab
için.
+**OSC çıkışı**
3.1.5. Öbür yön. Varsayılan kapalı; başka bir hedef girilene kadar bu
+bilgisayara gönderir ve geri besleme olmasın diye kendi OSC girişine göndermez. Ek hedefler satır
+satır `host:port` ya da `[ipv6]:port`. Pozitif saat gecikmesi fazı geri alır; hoparlör geç
+kalıyorsa ışık onu bekler.
+
+Adresler, değiştirilmedikçe `/cayadev` önekiyle gider. Seviye, bas, mid ve tiz tek bundle içindedir.
+Vuruş ve saat bundle'ı ana bilgisayar saatinin OSC zaman etiketini taşır. Dizeler UTF-8'dir.
+
+| Adres | Tür | Aralık | Ne zaman |
+|---|---|---|---|
+| `/level` `/bass` `/mid` `/treble` | float | 0..1 | seçilen hızda, en çok 30 Hz, tek bundle |
+| `/spectrum` | 16 float | 0..1 | seviyelerle; 30 Hz–16 kHz logaritmik bant |
+| `/hit/kick` `/hit/snare` `/hit/hat` | float | 0..1, sonra 0 | yakalama karesi gelince, ardından kapanış 0 |
+| `/silence` | int | 0 ya da 1 | seviye 400 ms boyunca 0,008 altında kalınca |
+| `/analysis/centroid` `/rolloff` `/flatness` `/crest` `/flux` `/spread` `/loudness` `/peak` `/dynamics` `/harmonic` `/percussive` `/width` | float | 0..1 | seviyelerle |
+| `/analysis/correlation` | float | -1..1 | seviyelerle |
+| `/analysis/pitch` | float | Hz | seviyelerle |
+| `/analysis/pitch/note` | string | nota | seviyelerle |
+| `/analysis/pitch/confidence` `/key/confidence` `/chord/confidence` | float | 0..1 | seviyelerle |
+| `/analysis/key` `/chord` | string | ad | seviyelerle |
+| `/tempo/bpm` `/tempo/confidence` | float | BPM, 0..1 | 0,01 BPM değişince, yoksa saniyede bir |
+| `/tempo/beat` | int int | vuruş 1..N, N | her vuruşta |
+| `/tempo/beat/phase` `/tempo/bar/phase` | float | 0..1 | seçilen hızda |
+| `/tempo/downbeat` | float | 1, sonra 0 | 1. vuruşta, sonraki saatte 0 |
+| `/transport` | string | `playing` ya da `stopped` | önizleme sesi hazırsa ya da değilse |
+| `/timeline/playing` | int | 0 ya da 1 | gösteri zaman çizelgesi |
+| `/scene` `/visualizer` `/background` `/milkdrop/preset` | string | ad | değişince ve 5 sn'de bir, boş preset dahil |
+| `/background/color/1` … `/8` | string | `#rrggbb` | ölçerin renkleri, yoksa tema renkleri |
+| `/show/blackout` `/show/autovj` | int | 0 ya da 1 | değişince ve 5 sn'de bir |
+| `/show/palette` `/show/transition` `/show/track` | string | ad | değişince ve 5 sn'de bir |
+| `/show/brightness` | float | panel değeri | arkaplan parlaklığı |
+| `/crossfade` | float | 0..1 | A/B ana karışımı |
+| `/audio/sensitivity` ve diğer panel kaydırıcıları | float ya da int | kaydırıcı aralığı | değişince ve 5 sn'de bir |
+| `/layer/count` | int | 0..32 | değişince |
+| `/layer/N/name` | string | ad | N 1'den başlar |
+| `/layer/N/opacity` | float | 0..1 | değişince |
+| `/layer/N/enabled` | int | 0 ya da 1 | değişince |
+| `/deck/row` `/deck/col` | int | yoksa -1 | en son çalan klip |
+| `/deck/active` | string | `satır:sütun` listesi | çalan her hücre |
+
-
+
@@ -1632,7 +1673,7 @@ npm test
npm start -- --smoke
```
-**2925 birim testi, hepsi geçiyor.** Satır çalıştırmak için değil, cevap denetlemek için yazıldılar:
+**2967 birim testi, hepsi geçiyor.** Satır çalıştırmak için değil, cevap denetlemek için yazıldılar:
- **Formüller**, tanımlarından elle türetilmiş değerlerle sınanıyor — Viviani eğrisinin küre üzerinde
kalması, simidin boru yarıçapı, Chladni'nin m↔n antisimetrisi, her çekicinin sınırlı kalması ve görüş
diff --git a/ROADMAP.md b/ROADMAP.md
index 780a54e9..5d591893 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -129,7 +129,7 @@ npm test
npm start -- --smoke
```
-- **2925 unit tests, all passing** on `main`. 703 of those shipped in v3.1.0;
+- **2967 unit tests, all passing** on `main`. 703 of those shipped in v3.1.0;
105 came with v3.1.1; 163 came with v3.1.2; 157 came with v3.1.3 — 1128 at
that tag — 469 more with v3.1.4, most of them from the MilkDrop work, and 1103
on `main` since.
diff --git a/docs/screenshots/modes-visualizer.jpg b/docs/screenshots/modes-visualizer.jpg
index e81af67b..97beb8b5 100644
Binary files a/docs/screenshots/modes-visualizer.jpg and b/docs/screenshots/modes-visualizer.jpg differ
diff --git a/docs/screenshots/panel-control.png b/docs/screenshots/panel-control.png
index 7abbd9a4..63045e50 100644
Binary files a/docs/screenshots/panel-control.png and b/docs/screenshots/panel-control.png differ
diff --git a/src/admin/admin.js b/src/admin/admin.js
index 723eebe4..64a78dec 100644
--- a/src/admin/admin.js
+++ b/src/admin/admin.js
@@ -2615,6 +2615,7 @@
// --- Dalga / çizgi biçimi (gelişmiş) ---
{ type: 'slider', path: 'visualizer.lineWidth', label: 'Çizgi Kalınlığı', min: 1, max: 12, step: 0.5, show: isWaveMode, group: 'Dalga Biçimi', advanced: true },
{ type: 'slider', path: 'visualizer.thickness', label: 'Genlik / Dolgu', min: 0.1, max: 1, step: 0.02, percent: true, show: () => MC().is('visualizer', v.type, 'thick'), group: 'Dalga Biçimi', advanced: true },
+ { type: 'slider', path: 'visualizer.trailHeight', label: 'Yükseklik', min: 0.4, max: 3, step: 0.05, percent: true, show: () => v.type === 'stereotrails', group: 'Dalga Biçimi', advanced: true },
// --- Frekans aralığı (gelişmiş) ---
{ type: 'slider', path: 'visualizer.minFreq', label: 'Min Frekans (Hz)', min: 20, max: 500, step: 5, show: isBandMode, group: 'Frekans Aralığı', advanced: true },
@@ -2992,6 +2993,16 @@
desc: 'TouchOSC, Resolume, Ableton veya QLab gibi kaynaklardan gelen OSC mesajlarını ayarlara bağlayın.',
controls: [{ type: 'controlpanel', surface: 'osc' }],
},
+ {
+ id: 'oscOut',
+ category: 'control',
+ icon: 'share',
+ wide: true,
+ title: 'OSC Çıkışı',
+ desc: 'Ses seviyelerini, davul vuruşlarını, tempoyu ve sahne değişimlerini OSC ile başka yazılımlara gönderin: Resolume, TouchDesigner, Max veya bir ışık masası.',
+ roots: ['oscOut'],
+ controls: [{ type: 'controlpanel', surface: 'oscout' }],
+ },
{
id: 'mcp',
category: 'control',
@@ -4593,6 +4604,8 @@
btn.classList.toggle('on', !!blackoutSaved);
window.SVIcons.set(btn, blackoutSaved ? 'sun' : 'moon', blackoutSaved ? 'Karartmayı Kaldır' : 'Karart');
}
+ window.SVShow = window.SVShow || {};
+ window.SVShow.blackout = !!blackoutSaved;
push(true);
render();
}
diff --git a/src/admin/autovj.js b/src/admin/autovj.js
index 6bab57ba..74714575 100644
--- a/src/admin/autovj.js
+++ b/src/admin/autovj.js
@@ -44,6 +44,7 @@
let lastSwitch = 0; // saniye
let barsSince = 0;
let lastBpmPaint = 0;
+ let lastOscClock = 0;
let rules = null; // { cursors, last }
let lastResult = null; // { kind, label } — durum satırı için
let lastFailure = null; // { code, kind }
@@ -325,6 +326,59 @@
return P().cfg().autovj;
}
+ /* OSC saati (#437). Karartma admin.js'te, deste ve zaman çizelgesi kendi
+ panellerinde durur. Yoklarsa alan boş kalır; ana süreç parçayı ekler. */
+ function oscClockPayload(tempo, audio, cfg) {
+ const bg = (cfg && cfg.background) || {};
+ const show = {
+ blackout: !!(window.SVShow && window.SVShow.blackout),
+ timeline: false,
+ deck: null,
+ palette: typeof bg.colorMode === 'string' ? bg.colorMode : '',
+ brightness: bg.gradient && Number.isFinite(bg.gradient.brightness) ? bg.gradient.brightness : 1,
+ transition: cfg.transition && typeof cfg.transition.type === 'string' ? cfg.transition.type : '',
+ autovj: !!(cfg.autovj && cfg.autovj.enabled),
+ layers: Array.isArray(cfg.layers) ? cfg.layers.slice(0, 32).map((l) => ({
+ name: l && typeof l.name === 'string' ? l.name : '',
+ opacity: l && Number.isFinite(Number(l.opacity)) ? Number(l.opacity) : 1,
+ enabled: !l || l.enabled !== false,
+ })) : [],
+ };
+ try {
+ const tp = window.SVTimelinePanel;
+ const tr = tp && typeof tp.transport === 'function' ? tp.transport() : null;
+ if (tr) show.timeline = tr.playing === true;
+ } catch { /* zaman çizelgesi yok */ }
+ try {
+ const panel = window.SVClipDeckPanel;
+ const eng = panel && typeof panel.engine === 'function' ? panel.engine() : null;
+ const slots = eng && typeof eng.activeSlots === 'function' ? eng.activeSlots() : null;
+ if (slots) {
+ let best = null;
+ const parts = [];
+ for (const s of slots) {
+ if (!best || (s.startedAt || 0) >= (best.startedAt || 0)) best = s;
+ if (s.slot) parts.push(s.slot.row + ':' + s.slot.col);
+ }
+ show.deck = {
+ row: best && best.slot ? best.slot.row : -1,
+ col: best && best.slot ? best.slot.col : -1,
+ active: parts.join(','),
+ };
+ }
+ } catch { /* klip destesi yok */ }
+ return {
+ beat: tempo.barPosition + 1,
+ beatsPerBar: tempo.beatsPerBar,
+ bpm: tempo.bpm,
+ phase: tempo.phase,
+ confidence: tempo.confidence,
+ playing: !!(audio && audio.ready),
+ hostTime: Date.now(),
+ show,
+ };
+ }
+
// --------------------------------------------------------------------------
// Döngü
// --------------------------------------------------------------------------
@@ -343,6 +397,24 @@
const fired = tempo.update(audio, now, dt);
if (fired && tempo.barPosition === 0) barsSince++;
+ /* OSC çıkışı (#437): tempo motorunun vuruşu, ölçüdeki yeri 1..N. Yalnız
+ çıkış açıkken: kapalıyken her vuruşta boşuna IPC olmasın. */
+ if (fired && cfg.oscOut && cfg.oscOut.enabled && window.api && window.api.reportTempoBeat) {
+ window.api.reportTempoBeat({
+ beat: tempo.barPosition + 1,
+ beatsPerBar: tempo.beatsPerBar,
+ bpm: tempo.bpm,
+ phase: tempo.phase,
+ confidence: tempo.confidence,
+ hostTime: Date.now(),
+ });
+ }
+ /* Faz ölçer hızında değil, tempo motorunun kendi karesinde gider.
+ 50 ms, vuruşlar arasında bir süpürme için yeter ve paneli meşgul etmez. */
+ if (cfg.oscOut && cfg.oscOut.enabled && window.api && window.api.reportTempoClock && now - lastOscClock >= 0.05) {
+ lastOscClock = now;
+ window.api.reportTempoClock(oscClockPayload(tempo, audio, cfg));
+ }
if (now - lastBpmPaint > 0.2) {
lastBpmPaint = now;
diff --git a/src/admin/control.js b/src/admin/control.js
index 6f4f80cc..eaee0f08 100644
--- a/src/admin/control.js
+++ b/src/admin/control.js
@@ -23,6 +23,7 @@
let learning = null; // { surface, id }
let lastSignal = { midi: '', osc: '' };
let oscState = { running: false, port: 0, error: null, lastAddress: '' };
+ let oscOutState = { running: false, host: '', port: 0, packets: 0, error: null };
let started = false;
// Sürülebilir hedefler. Aralıklar panel kaydırıcılarıyla aynı tutuldu ki
@@ -37,6 +38,7 @@
{ path: 'visualizer.gap', label: 'Görselleştirici · Bar Boşluğu', min: 0, max: 0.8 },
{ path: 'visualizer.lineWidth', label: 'Görselleştirici · Çizgi Kalınlığı', min: 1, max: 12 },
{ path: 'visualizer.thickness', label: 'Görselleştirici · Genlik', min: 0.1, max: 1 },
+ { path: 'visualizer.trailHeight', label: 'Görselleştirici · Yükseklik', min: 0.4, max: 3 },
{ path: 'background.gradient.speed', label: 'Arkaplan · Akış Hızı', min: 0, max: 2 },
{ path: 'background.gradient.audioReactivity', label: 'Arkaplan · Ses Tepkisi', min: 0, max: 2 },
{ path: 'background.gradient.brightness', label: 'Arkaplan · Parlaklık', min: 0.4, max: 1.6 },
@@ -568,6 +570,8 @@
);
}
nodes.push(mappingRows('midi'));
+ } else if (surface === 'oscout') {
+ oscOutNodes(cfg).forEach((n) => nodes.push(n));
} else {
const enable = el('input', {
type: 'checkbox',
@@ -629,6 +633,162 @@
return el('div', { class: 'control-panel' }, nodes);
}
+ // --------------------------------------------------------------------------
+ // OSC çıkışı (#437)
+ // --------------------------------------------------------------------------
+ /* Ana süreçteki denetimin (src/main/osc-out.js) aynısı; panel geçersiz
+ bir değeri baştan geri çeviriyor ki kullanıcı ne olduğunu görsün. */
+ const OSC_HOST = /^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
+ const OSC_PREFIX = /^(\/[A-Za-z0-9_-]{1,32}){0,4}$/;
+ /* Ana süreçteki validHost ile aynı kabul: IPv4, IPv6 ya da ana bilgisayar
+ adı. Bölge kimliği (%eth0) yok. Köşeli parantez yalnız alanda soyulur. */
+ function oscHostOk(v) {
+ let h = String(v || '').trim();
+ if (h.startsWith('[') && h.endsWith(']')) h = h.slice(1, -1);
+ if (!h || h.length > 253 || h.includes('%')) return false;
+ if (OSC_HOST.test(h)) return true;
+ if (!/^[0-9A-Fa-f:]+$/.test(h) || !h.includes(':')) return false;
+ const halves = h.split('::');
+ if (halves.length > 2) return false;
+ const groups = h.split(':');
+ if (groups.length > 8) return false;
+ return groups.every((g) => g.length <= 4);
+ }
+
+ function oscOutNodes(cfg) {
+ const el = P().el;
+ const o = cfg.oscOut;
+ /* Eski ayar dosyasında bu alanlar yok. Ana süreç yokluğu "açık" sayar;
+ kutu da öyle görünmeli. */
+ if (o.analysis == null) o.analysis = true;
+ if (o.latencyMs == null) o.latencyMs = 0;
+ if (o.extra == null) o.extra = '';
+ const nodes = [];
+ const sync = async () => {
+ P().push(true);
+ try { oscOutState = await window.api.oscOutSync(); } catch { /* servis kapalı */ }
+ P().rerender();
+ };
+ const toggle = (label, key) => {
+ const box = el('input', { type: 'checkbox', onchange: (e) => { o[key] = e.target.checked; sync(); } });
+ box.checked = !!o[key];
+ return P().row(label, el('label', { class: 'switch' }, [box, el('span', { class: 'track' })]));
+ };
+ const text = (value, ok, apply, bad) => el('input', {
+ class: 'p-in', type: 'text', value, spellcheck: 'false', autocomplete: 'off',
+ onchange: (e) => {
+ const v = String(e.target.value).trim();
+ if (!ok(v)) {
+ P().toast(T(bad), 'err');
+ e.target.value = value;
+ return;
+ }
+ apply(v);
+ sync();
+ },
+ });
+
+ nodes.push(toggle('OSC Çıkışı Etkin', 'enabled'));
+ nodes.push(P().row('Hedef Adres', text(o.host, oscHostOk, (v) => {
+ o.host = v.startsWith('[') && v.endsWith(']') ? v.slice(1, -1) : v;
+ }, 'Adres bir IPv4, IPv6 ya da ana bilgisayar adı olmalı.')));
+ nodes.push(P().row('Hedef Port', el('input', {
+ class: 'p-in p-num', type: 'number', min: '1', max: '65535', value: o.port,
+ onchange: (e) => {
+ const port = P().portValue(e.target, o.port, 1);
+ if (port == null) return;
+ o.port = port;
+ sync();
+ },
+ })));
+ nodes.push(P().row('Seviye Gönderim Hızı (Hz)', el('input', {
+ class: 'p-in p-num', type: 'number', min: '1', max: '30', value: o.rate,
+ onchange: (e) => {
+ const n = Number(e.target.value);
+ if (!Number.isInteger(n) || n < 1 || n > 30) {
+ P().toast(T('Hız 1–30 arasında bir tam sayı olmalı.'), 'err');
+ e.target.value = String(o.rate);
+ return;
+ }
+ o.rate = n;
+ sync();
+ },
+ })));
+ nodes.push(P().row('Adres Öneki', text(o.prefix, (v) => OSC_PREFIX.test(v.replace(/\/+$/, '')),
+ (v) => { o.prefix = v.replace(/\/+$/, ''); }, 'Önek /cayadev gibi olmalı: en çok dört parça, harf, rakam, - ve _.')));
+ nodes.push(P().row('Saat Gecikmesi (ms)', el('input', {
+ class: 'p-in p-num', type: 'number', min: '-2000', max: '2000', step: '1', value: o.latencyMs || 0,
+ onchange: (e) => {
+ const n = Number(e.target.value);
+ if (!Number.isInteger(n) || n < -2000 || n > 2000) {
+ P().toast(T('Gecikme -2000 ile 2000 ms arasında bir tam sayı olmalı.'), 'err');
+ e.target.value = String(o.latencyMs || 0);
+ return;
+ }
+ o.latencyMs = n;
+ sync();
+ },
+ })));
+ nodes.push(P().row('Ek Hedefler', el('textarea', {
+ class: 'p-in', rows: '3', spellcheck: 'false', value: o.extra || '',
+ onchange: (e) => { o.extra = e.target.value; sync(); },
+ })));
+ nodes.push(toggle('Ses Seviyeleri', 'levels'));
+ nodes.push(toggle('Davul Vuruşları', 'hits'));
+ nodes.push(toggle('Tempo ve Vuruş Saati', 'tempo'));
+ nodes.push(toggle('Sahne ve Mod Değişimleri', 'state'));
+ nodes.push(toggle('Çözümleme ve Tayf', 'analysis'));
+
+ const st = oscOutState || {};
+ const stBox = el('label', { class: 'lbl studio-status ' + (st.error ? 'err' : st.running ? 'ok' : '') });
+ if (st.error === 'loop') {
+ stBox.appendChild(el('span', { icon: 'x', text: 'Hedef bu bilgisayarın OSC girişi; geri besleme olmasın diye gönderilmiyor. Portu değiştirin.' }));
+ } else if (st.error) {
+ stBox.appendChild(el('span', { icon: 'x', text: st.error }));
+ } else if (st.running) {
+ stBox.appendChild(el('span', { icon: 'check' }));
+ stBox.appendChild(el('span', { text: 'Gönderiliyor' }));
+ stBox.appendChild(el('span', { class: 'st-num', text: ' ' + st.host + ':' + st.port + ' · ' }));
+ stBox.appendChild(el('span', { id: 'oscOutPackets', class: 'st-num', text: String(st.packets || 0) + ' ' }));
+ stBox.appendChild(el('span', { text: 'paket' }));
+ pollOscOutCount();
+ } else {
+ stBox.appendChild(el('span', { text: 'Kapalı' }));
+ }
+ nodes.push(el('div', { class: 'ctrl' }, [el('div', { class: 'row' }, [stBox])]));
+ nodes.push(el('div', {
+ class: 'studio-note',
+ text: 'Seviye, bas, mid ve tiz tek pakette gider. Vuruştan sonra 0 gelir. Saat: BPM, faz (0..1), ölçü fazı, ölçü başı, çalıyor ya da durdu. Ayrıntılı adres ağacı README dosyasında.',
+ }));
+ nodes.push(el('div', {
+ class: 'studio-note',
+ text: 'Ek hedefler satır satır: 10.0.0.8:9001 ya da [::1]:9001. Pozitif gecikme saati geri alır; hoparlör geç kalıyorsa ışık onu bekler.',
+ }));
+ return nodes;
+ }
+
+ /* Paket sayacı canlı: kart ekrandayken saniyede bir tazelenir, paneli
+ yeniden çizmeden. Kalıcı bir zamanlayıcı yok; sayaç ekrandan kalkınca
+ zincir kendiliğinden durur. */
+ let oscOutPoll = 0;
+ function pollOscOutCount() {
+ if (oscOutPoll || !window.api || !window.api.oscOutStatus) return;
+ const tick = async () => {
+ oscOutPoll = 0;
+ const n = document.getElementById('oscOutPackets');
+ if (!n) return;
+ try {
+ const st = await window.api.oscOutStatus();
+ if (st) {
+ oscOutState = st;
+ n.textContent = String(st.packets || 0) + ' ';
+ }
+ } catch { /* servis kapalı */ }
+ if (!oscOutPoll) oscOutPoll = setTimeout(tick, 1000);
+ };
+ oscOutPoll = setTimeout(tick, 1000);
+ }
+
async function init() {
if (started) return;
started = true;
@@ -637,6 +797,10 @@
window.api.onOscMessage(onOsc);
window.api.onOscStatus((s) => { oscState = s; });
try { oscState = await window.api.oscStatus(); } catch { /* servis kapalı */ }
+ if (window.api.onOscOutStatus) window.api.onOscOutStatus((s) => { oscOutState = s; });
+ if (window.api.oscOutStatus) {
+ try { oscOutState = await window.api.oscOutStatus(); } catch { /* servis kapalı */ }
+ }
}
window.SVControl = { panel, init, TARGETS, allTargets, mappedValue, runAction };
diff --git a/src/admin/index.html b/src/admin/index.html
index 34936b14..644a323c 100644
--- a/src/admin/index.html
+++ b/src/admin/index.html
@@ -272,6 +272,7 @@
Sahneler
+
diff --git a/src/admin/modulation-panel.js b/src/admin/modulation-panel.js
index f8fc82e8..3b14efe9 100644
--- a/src/admin/modulation-panel.js
+++ b/src/admin/modulation-panel.js
@@ -43,7 +43,7 @@
// alan ham anahtarıyla görünür — yeni alan eklendiğinde panel bozulmaz.
const FIELD_LABELS = {
glow: 'Parlama', opacity: 'Saydamlık', thickness: 'Kalınlık', gap: 'Boşluk',
- sensitivity: 'Duyarlılık', lineWidth: 'Çizgi Kalınlığı', smoothing: 'Yumuşatma',
+ sensitivity: 'Duyarlılık', lineWidth: 'Çizgi Kalınlığı', trailHeight: 'Yükseklik', smoothing: 'Yumuşatma',
speed: 'Hız', bright: 'Parlaklık', react: 'Tepki', scale: 'Ölçek', rotate: 'Dönüş',
spin: 'Dönüş Hızı', tilt: 'Eğim', zoom: 'Yakınlaşma', deform: 'Bozulma',
alpha: 'Saydamlık', pointSize: 'Nokta Boyutu', resolution: 'Çözünürlük',
diff --git a/src/admin/scene-panels.js b/src/admin/scene-panels.js
index 9a6f9c06..163c1005 100644
--- a/src/admin/scene-panels.js
+++ b/src/admin/scene-panels.js
@@ -1542,6 +1542,9 @@
if (MC().is('visualizer', l.type, 'thick')) {
out.push(miniSlider('Genlik / Dolgu', () => getV('thickness', 0.5), (v) => setV('thickness', v), { min: 0.1, max: 1, step: 0.02, percent: true, def: 0.5}));
}
+ if (l.type === 'stereotrails') {
+ out.push(miniSlider('Yükseklik', () => getV('trailHeight', 1), (v) => setV('trailHeight', v), { min: 0.4, max: 3, step: 0.05, percent: true, def: 1 }));
+ }
return out;
}
diff --git a/src/exporter/index.html b/src/exporter/index.html
index c898ea15..9f7ac880 100644
--- a/src/exporter/index.html
+++ b/src/exporter/index.html
@@ -69,6 +69,7 @@
+
diff --git a/src/main/drum-hits.js b/src/main/drum-hits.js
new file mode 100644
index 00000000..dc31440e
--- /dev/null
+++ b/src/main/drum-hits.js
@@ -0,0 +1,66 @@
+/*
+ * SoundVisualizer — CaYaDev Ses Görselleştirici
+ * Copyright (c) 2026 Çağan Turgut (CaYatur) — CaYaDev, https://cayadev.com
+ * https://github.com/CaYatur/SoundVisualizer
+ * SPDX-License-Identifier: MIT
+ */
+'use strict';
+/* Kick, trampet ve hi-hat. Yakalama yardımcısının yazdığı tayf karesi ana
+ sürece ulaşır ulaşmaz çalışır. Çizim karesini beklemez: kare hızı sınırı
+ bir vuruşu 30 ms'den fazla tutabiliyordu.
+
+ WASAPI geri çağrısının kendisi yalnız örnek kopyalar. Algılayıcı o iş
+ parçacığında değil, aynı karenin ana süreçteki tesliminde koşar. Ses
+ iş parçacığına FFT bindirmek kesinti yapardı. Bantlar ve eşikler
+ src/shared/analysis.js ile aynıdır. */
+
+const { Onset } = require('../shared/onset.js');
+
+const FFT_SIZE = 2048;
+
+function bandEnergy(spec, binHz, f0, f1) {
+ const i0 = Math.max(1, Math.floor(f0 / binHz));
+ const i1 = Math.min(spec.length - 1, Math.ceil(f1 / binHz));
+ if (i1 < i0) return 0;
+ let s = 0;
+ for (let i = i0; i <= i1; i++) s += spec[i] * spec[i];
+ return Math.sqrt(s / (i1 - i0 + 1));
+}
+
+class DrumHits {
+ constructor() {
+ this.kick = new Onset({ refractory: 0.09, floor: 0.3, gate: 0.008 });
+ this.snare = new Onset({ refractory: 0.09, floor: 0.3, gate: 0.008 });
+ this.hat = new Onset({ refractory: 0.045, floor: 0.3, gate: 0.008 });
+ this.lastAt = 0;
+ this.sent = { kick: 0, snare: 0, hat: 0 };
+ this.spec = new Float32Array(FFT_SIZE / 2);
+ }
+
+ /* freq: 1024 bayt, 0..255. now: ms. Değişmediyse null. Kapanış 0 da
+ bir değişikliktir ve bir kez döner. */
+ push(freq, sampleRate, now) {
+ if (!freq || freq.length < 8) return null;
+ const sr = sampleRate > 1000 ? sampleRate : 48000;
+ const binHz = sr / FFT_SIZE;
+ const n = Math.min(freq.length, this.spec.length);
+ const spec = this.spec;
+ for (let i = 0; i < n; i++) spec[i] = freq[i] / 255;
+ const dt = this.lastAt ? Math.min(0.25, Math.max(0.001, (now - this.lastAt) / 1000)) : 0.014;
+ this.lastAt = now;
+ const hits = {
+ kick: this.kick.push(bandEnergy(spec, binHz, 30, 130), dt),
+ snare: this.snare.push(bandEnergy(spec, binHz, 180, 900), dt),
+ hat: this.hat.push(bandEnergy(spec, binHz, 6000, 14000), dt),
+ };
+ let changed = false;
+ for (const k of ['kick', 'snare', 'hat']) {
+ if ((hits[k] > 0 || this.sent[k] > 0) && hits[k] !== this.sent[k]) changed = true;
+ }
+ if (!changed) return null;
+ this.sent = hits;
+ return hits;
+ }
+}
+
+module.exports = { DrumHits, bandEnergy, FFT_SIZE };
diff --git a/src/main/main.js b/src/main/main.js
index 52d1ea29..bf14188e 100644
--- a/src/main/main.js
+++ b/src/main/main.js
@@ -12,11 +12,13 @@ const fs = require('fs');
const url = require('url');
const { spawn } = require('child_process');
const nativeAudio = require('./native-audio');
+const { DrumHits } = require('./drum-hits');
const dynamicLighting = require('./dynamic-lighting');
const lightingIdentity = require('./lighting-identity');
const streamServer = require('./stream-server');
const oscServer = require('./osc-server');
const artnet = require('./artnet');
+const oscOut = require('./osc-out');
const openrgb = require('./openrgb');
const textureShare = require('./texture-share');
const presetsStore = require('./presets-store');
@@ -1124,12 +1126,21 @@ function captureWanted() {
// Seçili ses kaynak(lar)ının yakalamasını başlat; kareleri hem görselleştiriciye
// hem de (istendiyse) yönetici panelinin önizlemesine ilet
+/* Yakalama karesi gelir gelmez vuruş. Çizim karesindeki algılayıcı,
+ dosya çalmada durur; yerel kare akarken o yol susar. */
+const nativeDrums = new DrumHits();
+
function startVisualizerCapture() {
const sources = configuredSources();
lastCaptureSource = sources;
nativeAudio.startCapture(
sources,
(frame) => {
+ if (!HW_OFF && frame && frame.freq && currentConfig && currentConfig.oscOut
+ && currentConfig.oscOut.enabled === true && currentConfig.oscOut.hits !== false) {
+ const hit = nativeDrums.push(frame.freq, frame.sampleRate, Date.now());
+ if (hit) oscOut.hit(currentConfig.oscOut, hit);
+ }
if (SMOKE) {
global.__smokeFrames = (global.__smokeFrames || 0) + 1;
/* Kare iki kanalı da taşımalı (#566). Sessiz bir aygıtta sol ve sağ
@@ -2397,6 +2408,7 @@ function applyIncomingConfig(config, opts) {
syncStreamServer();
syncOscServer();
syncArtnet();
+ syncOscOut();
syncOpenRgb();
syncTextureShare();
syncNowPlaying();
@@ -2564,6 +2576,9 @@ ipcMain.on('audio-meter', (e, data) => {
if (currentConfig && currentConfig.artnet && currentConfig.artnet.enabled) {
artnet.send(currentConfig.artnet, data);
}
+ if (currentConfig && currentConfig.oscOut && currentConfig.oscOut.enabled) {
+ oscOut.send(currentConfig.oscOut, data, oscOutContext());
+ }
/* OpenRGB, Dynamic Lighting ile AYNI görünüm ayarlarını kullanır
(cfg.lighting): iki ayrı ayar olsaydı aynı masadaki iki aygıt iki
farklı renk yakardı. Windows'ta ikisi birlikte de çalışabilir. */
@@ -3076,6 +3091,79 @@ function syncArtnet() {
});
}
+/* OSC çıkışı (#437). OSC girişinin ayarı da veriliyor: hedef bu
+ bilgisayarın OSC girişiyse osc-out.js göndermiyor (geri besleme). Art-Net
+ gibi otomasyonda (HW_OFF) ağa paket gitmiyor. */
+function syncOscOut() {
+ const o = (currentConfig && currentConfig.oscOut) || {};
+ if (!o.enabled || HW_OFF) return oscOut.stop().then(() => oscOut.status());
+ const oscIn = currentConfig.control && currentConfig.control.osc;
+ return oscOut.start(o, oscIn).then((st) => {
+ notifyAdmin('oscout-status', st);
+ return st;
+ });
+}
+
+/* Ana sürecin bildikleri: tempo panelden (mcpLive), sahne adı ve ekrandaki
+ görselleştirici/arkaplan türü ayardan. Yığın açıkken tür ilk görünür
+ katmandan okunuyor (layers.js currentType), Studio ve MCP gibi. */
+/* Panelin saat iletisi (tempo:clock) son fazı, çalmayı, karartmayı ve
+ desteyi bırakır. Ölçer karesi bunları da taşır; imza değişmediyse
+ planlayıcı yeniden yollamaz. */
+let oscLive = {
+ phase: null, beat: 0, beatsPerBar: 4, bpm: 0, confidence: 0,
+ playing: false, blackout: false, timeline: false, deck: null,
+};
+
+function oscTrackTitle(st) {
+ if (!st || !st.has || typeof st.title !== 'string' || !st.title) return '';
+ return st.artist ? st.artist + ' — ' + st.title : st.title;
+}
+
+function oscLayers(cfg) {
+ const layers = cfg && Array.isArray(cfg.layers) ? cfg.layers : [];
+ return layers.slice(0, 32).map((l) => ({
+ name: l && typeof l.name === 'string' ? l.name : '',
+ opacity: l && Number.isFinite(Number(l.opacity)) ? Number(l.opacity) : 1,
+ enabled: !l || l.enabled !== false,
+ }));
+}
+
+function oscOutContext() {
+ const cfg = currentConfig || {};
+ const scene = (cfg.scenes || []).find((s) => s && s.id === cfg._activeSceneId);
+ const L = stackHelpers();
+ const typeOf = (section) => (L ? L.currentType(cfg, section) : cfg[section] && cfg[section].type) || '';
+ const bg = cfg.background || {};
+ const bpm = Number.isFinite(oscLive.bpm) && oscLive.bpm > 0 ? oscLive.bpm : mcpLive.bpm;
+ const confidence = Number.isFinite(oscLive.confidence) ? oscLive.confidence : mcpLive.confidence;
+ return {
+ bpm,
+ confidence,
+ phase: oscLive.phase,
+ beat: oscLive.beat,
+ beatsPerBar: oscLive.beatsPerBar || (cfg.autovj && cfg.autovj.beatsPerBar) || 4,
+ playing: oscLive.playing === true,
+ scene: scene && typeof scene.name === 'string' ? scene.name : '',
+ visualizer: typeOf('visualizer'),
+ background: typeOf('background'),
+ colors: bg.gradient && Array.isArray(bg.gradient.colors) ? bg.gradient.colors : [],
+ show: {
+ blackout: oscLive.blackout === true,
+ palette: typeof bg.colorMode === 'string' ? bg.colorMode : '',
+ brightness: bg.gradient && Number.isFinite(bg.gradient.brightness) ? bg.gradient.brightness : 1,
+ transition: cfg.transition && typeof cfg.transition.type === 'string' ? cfg.transition.type : '',
+ autovj: !!(cfg.autovj && cfg.autovj.enabled),
+ track: oscTrackTitle(mediaSession.current()),
+ timeline: oscLive.timeline === true,
+ layers: oscLayers(cfg),
+ deck: oscLive.deck,
+ crossfade: cfg.crossfade && Number.isFinite(Number(cfg.crossfade.value)) ? Number(cfg.crossfade.value) : 0,
+ controls: oscOut.controlValues(cfg),
+ },
+ };
+}
+
/* Ayarları değişmediyse ve pencere çalışıyorsa yeniden başlatılmaz. Her
ayar gönderiminde start() çağrılıyordu: pencereye bütün yapılandırma
kopyalanıp yeniden yollanıyor, söz kitaplığı diskten baştan okunuyordu.
@@ -3252,6 +3340,48 @@ ipcMain.handle('osc:status', () => oscServer.status());
ipcMain.handle('osc:sync', () => syncOscServer());
ipcMain.handle('artnet:status', () => artnet.status());
ipcMain.handle('artnet:sync', () => syncArtnet());
+ipcMain.handle('oscout:status', () => oscOut.status());
+ipcMain.handle('oscout:sync', () => syncOscOut());
+/* Tempo motorunun vuruşu panelden geliyor (autovj.js). Yalnız panel
+ penceresinden kabul edilir: vuruş başka bir sayfadan uydurulamasın. */
+function noteOscLive(info) {
+ if (!info || typeof info !== 'object') return;
+ if (Number.isFinite(info.phase)) oscLive.phase = info.phase;
+ if (Number.isFinite(info.beat)) oscLive.beat = info.beat;
+ if (Number.isFinite(info.beatsPerBar)) oscLive.beatsPerBar = info.beatsPerBar;
+ if (Number.isFinite(info.bpm)) oscLive.bpm = info.bpm;
+ if (Number.isFinite(info.confidence)) oscLive.confidence = info.confidence;
+ if (typeof info.playing === 'boolean') oscLive.playing = info.playing;
+ const show = info.show && typeof info.show === 'object' ? info.show : null;
+ if (show) {
+ if (typeof show.blackout === 'boolean') oscLive.blackout = show.blackout;
+ if (typeof show.timeline === 'boolean') oscLive.timeline = show.timeline;
+ if (show.deck && typeof show.deck === 'object') oscLive.deck = show.deck;
+ }
+}
+
+ipcMain.on('tempo:beat', (e, info) => {
+ if (!adminWin || adminWin.isDestroyed() || e.sender !== adminWin.webContents) return;
+ if (!currentConfig || !currentConfig.oscOut || !currentConfig.oscOut.enabled) return;
+ noteOscLive(info);
+ oscOut.beat(currentConfig.oscOut, info);
+});
+/* Faz, çalma ve gösteri durumu. Vuruş kenarı tempo:beat'te kalır. */
+ipcMain.on('tempo:clock', (e, info) => {
+ if (!adminWin || adminWin.isDestroyed() || e.sender !== adminWin.webContents) return;
+ if (!currentConfig || !currentConfig.oscOut || !currentConfig.oscOut.enabled) return;
+ noteOscLive(info);
+ const track = oscTrackTitle(mediaSession.current());
+ const show = Object.assign({}, info && info.show, { track });
+ oscOut.clock(currentConfig.oscOut, Object.assign({}, info, { show }));
+});
+/* Vuruş, çizim karesinden. Yalnız ölçeri kabul edilen pencereden. */
+ipcMain.on('osc-hit', (e, hits) => {
+ const primary = meterWindow();
+ if (primary && e.sender !== primary.webContents) return;
+ if (!currentConfig || !currentConfig.oscOut || !currentConfig.oscOut.enabled) return;
+ oscOut.hit(currentConfig.oscOut, hits);
+});
ipcMain.handle('openrgb:status', () => openrgb.status());
ipcMain.handle('openrgb:sync', () => syncOpenRgb({ retry: true }));
/* Bağlı değilken "Aygıtları Yenile" bağlanmayı yeniden dener: OpenRGB
@@ -4504,6 +4634,7 @@ app.whenReady().then(async () => {
syncStreamServer().catch(() => {});
syncOscServer().catch(() => {});
syncArtnet().catch(() => {});
+ syncOscOut().catch(() => {});
syncOpenRgb().catch(() => {});
syncTextureShare().catch(() => {});
@@ -6798,6 +6929,7 @@ function shutdownCleanup() {
streamServer.stop().catch(() => {});
oscServer.stop().catch(() => {});
artnet.stop().catch(() => {});
+ oscOut.stop().catch(() => {});
dynamicLighting.stop().catch(() => {});
openrgb.stop().catch(() => {});
textureShare.stop().catch(() => {});
@@ -6972,7 +7104,7 @@ async function runShots() {
['output', 'stream', 'panel-output.png'],
['library', 'templates', 'panel-templates.png'],
['studio', null, 'panel-studio.png'],
- ['control', null, 'panel-control.png'],
+ ['control', 'oscOut', 'panel-control.png'],
];
if (adminWin && !adminWin.isDestroyed()) {
@@ -7445,7 +7577,7 @@ async function runShots() {
);
vw.webContents.send('config', cfg);
// Geçmiş biriktiren ve yavaş kurulan modlar daha uzun bekler
- await wait(m.engine || /^(spectrogram|ribbon|wave3d|terrain|galaxy|attractorfield|fireworks|flowfield|flock|ropes)$/.test(m.id) ? 3200 : 1800);
+ await wait(m.engine || /^(spectrogram|ribbon|wave3d|terrain|galaxy|attractorfield|fireworks|flowfield|flock|ropes|stereotrails)$/.test(m.id) ? 3200 : 1800);
const img = await vw.webContents.capturePage();
tiles.push({ img: await sharp(img.toPNG()).resize(TW, TH).png().toBuffer(), name: label(m.label) });
}
diff --git a/src/main/osc-out.js b/src/main/osc-out.js
new file mode 100644
index 00000000..b598323c
--- /dev/null
+++ b/src/main/osc-out.js
@@ -0,0 +1,797 @@
+/*
+ * SoundVisualizer — CaYaDev Ses Görselleştirici
+ * Copyright (c) 2026 Çağan Turgut (CaYatur) — CaYaDev, https://cayadev.com
+ * https://github.com/CaYatur/SoundVisualizer
+ * SPDX-License-Identifier: MIT
+ */
+'use strict';
+/* OSC (Open Sound Control) ÇIKIŞI — UDP (#437).
+
+ Görselleştiricinin ölçtüğünü başka yazılımlara yollar: Resolume,
+ TouchDesigner, Max/MSP, ışık masaları. Uygulama böylece bir çözümleme
+ kaynağı olur; OSC girişinin (osc-server.js) tersi.
+
+ Adres ağacı README'de, türü ve aralığıyla. Önek varsayılan /cayadev.
+ Seviye, bas, mid ve tiz TEK #bundle içinde gider: bir UDP kaybı bantları
+ birbirinden koparamasın. Vuruş ve saat iletileri de bundle'dır ve OSC
+ zaman etiketi taşır (ana bilgisayar saati). Böylece geç kalan bir paket
+ hâlâ yerine oturtulabilir.
+
+ GÜVENLİK: varsayılan kapalı. Hedef bu bilgisayarın açık OSC girişiyse
+ gönderilmez. Her alan burada yeniden denetlenir. */
+
+const dgram = require('dgram');
+const dns = require('dns');
+const net = require('net');
+const os = require('os');
+
+const DEFAULTS = {
+ enabled: false,
+ host: '127.0.0.1',
+ port: 9001,
+ rate: 30,
+ prefix: '/cayadev',
+ levels: true,
+ hits: true,
+ tempo: true,
+ state: true,
+ analysis: true,
+ latencyMs: 0,
+ extra: '',
+};
+const MAX_RATE = 30;
+const BPM_STEP = 0.01; // bunun altındaki tempo oynaması gürültüdür
+const HEARTBEAT_MS = 1000;
+const STATE_REPEAT_MS = 5000;
+const SILENCE_LEVEL = 0.008;
+const SILENCE_HOLD_MS = 400;
+const MAX_STRING = 200;
+const MAX_TARGETS = 8;
+const NTP_UNIX = 2208988800;
+const LOOP = 'loop';
+const STATE_KEYS = ['scene', 'visualizer', 'background', 'milkdrop/preset'];
+const ANALYSIS_F = [
+ 'centroid', 'rolloff', 'flatness', 'crest', 'flux', 'spread',
+ 'loudness', 'peak', 'dynamics', 'harmonic', 'percussive', 'width',
+];
+/* Giriş ağacının kaydırıcıları. Çıkış bunları aynı yolda geri yollar. */
+const CONTROL_PATHS = [
+ { path: 'audio.sensitivity' },
+ { path: 'audio.smoothing' },
+ { path: 'audio.bassBoost' },
+ { path: 'visualizer.sensitivity' },
+ { path: 'visualizer.glow' },
+ { path: 'visualizer.barCount', int: true },
+ { path: 'visualizer.gap' },
+ { path: 'visualizer.lineWidth' },
+ { path: 'visualizer.thickness' },
+ { path: 'visualizer.trailHeight' },
+ { path: 'background.gradient.speed' },
+ { path: 'background.gradient.audioReactivity' },
+ { path: 'background.gradient.brightness' },
+ { path: 'background.gradient.audioHue' },
+ { path: 'background.gradient.vignette' },
+ { path: 'logo.opacity' },
+ { path: 'logo.scale' },
+ { path: 'feedback.zoom' },
+ { path: 'feedback.decay' },
+ { path: 'feedback.warp' },
+ { path: 'feedback.rotate' },
+ { path: 'media.opacity' },
+ { path: 'media.kaleido', int: true },
+ { path: 'milkdrop.blendTime' },
+ { path: 'milkdrop.autoNext', int: true },
+ { path: 'milkdrop.autoNextRand', int: true },
+ { path: 'milkdrop.hardCutThreshold' },
+ { path: 'milkdrop.mesh' },
+ { path: 'milkdrop.renderScale' },
+];
+
+const clamp = (v, a, b) => (v < a ? a : v > b ? b : v);
+const unit = (v) => (Number.isFinite(v) ? clamp(v, 0, 1) : 0);
+const int32 = (v) => clamp(Math.round(Number(v) || 0), -2147483648, 2147483647);
+const finite = (v) => (Number.isFinite(v) ? v : 0);
+
+function readPath(obj, path) {
+ let o = obj;
+ for (const k of String(path || '').split('.')) {
+ if (o == null) return undefined;
+ o = o[k];
+ }
+ return o;
+}
+
+/* Girişin yazdığı kaydırıcıların şu anki değeri. Masa fader'ı bunu duyar. */
+function controlValues(cfg) {
+ const out = [];
+ for (const s of CONTROL_PATHS) {
+ const n = Number(readPath(cfg, s.path));
+ if (!Number.isFinite(n)) continue;
+ out.push({ path: s.path, int: !!s.int, value: s.int ? Math.round(n) : n });
+ }
+ return out;
+}
+
+// --------------------------------------------------------------- ayarlar
+const HOSTNAME = /^(?=.{1,253}$)[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)*$/;
+
+function bareHost(h) {
+ const s = typeof h === 'string' ? h.trim() : '';
+ if (s.startsWith('[') && s.endsWith(']')) return s.slice(1, -1);
+ return s;
+}
+
+/* IPv4, IPv6 (bölge kimliği yok) ya da çözülecek bir ana bilgisayar adı.
+ "evil host" ve "a/b" kabul edilmez. */
+function validHost(h) {
+ const host = bareHost(h);
+ if (!host || host.length > 253 || host.includes('%')) return false;
+ if (net.isIPv4(host) || net.isIPv6(host)) return true;
+ return HOSTNAME.test(host);
+}
+
+function parseTargetLine(line) {
+ const s = String(line || '').trim();
+ if (!s || s.startsWith('#')) return null;
+ const bracket = s.match(/^\[([^\]]+)\]:(\d+)$/);
+ const plain = bracket ? null : s.match(/^([^:\s]+):(\d+)$/);
+ const m = bracket || plain;
+ if (!m) return null;
+ const port = Number(m[2]);
+ if (!validHost(m[1]) || !Number.isInteger(port) || port < 1 || port > 65535) return null;
+ return { host: bareHost(m[1]), port };
+}
+
+function targetsOf(o) {
+ const list = [{ host: o.host, port: o.port }];
+ const seen = new Set([o.host + ':' + o.port]);
+ for (const line of String(o.extra || '').split(/\r?\n/)) {
+ const t = parseTargetLine(line);
+ if (!t) continue;
+ const key = t.host + ':' + t.port;
+ if (seen.has(key)) continue;
+ seen.add(key);
+ list.push(t);
+ if (list.length >= MAX_TARGETS) break;
+ }
+ return list;
+}
+
+function normalize(cfg) {
+ const c = cfg && typeof cfg === 'object' ? cfg : {};
+ const host = bareHost(c.host);
+ const port = Number(c.port);
+ const rate = Number(c.rate);
+ const prefix = typeof c.prefix === 'string' ? c.prefix.trim().replace(/\/+$/, '') : null;
+ const latency = Number(c.latencyMs);
+ return {
+ enabled: c.enabled === true,
+ host: validHost(host) ? host : DEFAULTS.host,
+ port: Number.isInteger(port) && port >= 1 && port <= 65535 ? port : DEFAULTS.port,
+ rate: Number.isFinite(rate) ? clamp(Math.round(rate), 1, MAX_RATE) : DEFAULTS.rate,
+ prefix: prefix !== null && /^(\/[A-Za-z0-9_-]{1,32}){0,4}$/.test(prefix) ? prefix : DEFAULTS.prefix,
+ levels: c.levels !== false,
+ hits: c.hits !== false,
+ tempo: c.tempo !== false,
+ state: c.state !== false,
+ analysis: c.analysis !== false,
+ latencyMs: Number.isFinite(latency) ? clamp(Math.round(latency), -2000, 2000) : DEFAULTS.latencyMs,
+ extra: typeof c.extra === 'string' ? c.extra : DEFAULTS.extra,
+ };
+}
+
+// ------------------------------------------------------------- kodlama
+function oscString(s) {
+ let str = String(s == null ? '' : s).replace(/\0/g, '');
+ if (Buffer.byteLength(str, 'utf8') > MAX_STRING) {
+ const chars = Array.from(str);
+ while (chars.length && Buffer.byteLength(chars.join(''), 'utf8') > MAX_STRING) chars.pop();
+ str = chars.join('');
+ }
+ const b = Buffer.from(str, 'utf8');
+ const out = Buffer.alloc((Math.floor(b.length / 4) + 1) * 4);
+ b.copy(out);
+ return out;
+}
+
+function encodeMessage(address, args) {
+ let tags = ',';
+ const parts = [];
+ for (const a of Array.isArray(args) ? args : []) {
+ const t = a && a[0];
+ const v = a && a[1];
+ if (t === 'f') {
+ const b = Buffer.alloc(4);
+ b.writeFloatBE(Number.isFinite(v) ? v : 0, 0);
+ parts.push(b);
+ tags += 'f';
+ } else if (t === 'i') {
+ const b = Buffer.alloc(4);
+ b.writeInt32BE(int32(v), 0);
+ parts.push(b);
+ tags += 'i';
+ } else if (t === 's') {
+ parts.push(oscString(v));
+ tags += 's';
+ }
+ }
+ return Buffer.concat([oscString(address), oscString(tags)].concat(parts));
+}
+
+/* OSC zaman etiketi: 1900 tabanlı NTP, 32 bit saniye + 32 bit kesir.
+ 2036 taşması bu sürümün ömründe yok. Negatif saat 0'a çekilir. */
+function ntpTimetag(ms) {
+ const t = Number.isFinite(ms) ? ms : 0;
+ const clamped = t < 0 ? 0 : t;
+ const sec = Math.floor(clamped / 1000) + NTP_UNIX;
+ const frac = Math.round((clamped % 1000) / 1000 * 0x100000000);
+ const b = Buffer.alloc(8);
+ b.writeUInt32BE(sec >>> 0, 0);
+ b.writeUInt32BE((frac >= 0x100000000 ? 0xffffffff : frac) >>> 0, 4);
+ return b;
+}
+
+function encodeBundle(messages, timeMs) {
+ const parts = [oscString('#bundle'), ntpTimetag(timeMs)];
+ for (const [address, args] of messages || []) {
+ const m = encodeMessage(address, args);
+ const size = Buffer.alloc(4);
+ size.writeInt32BE(m.length, 0);
+ parts.push(size, m);
+ }
+ return Buffer.concat(parts);
+}
+
+function asBundle(now, messages) {
+ if (!messages || !messages.length) return null;
+ return { bundle: true, time: Number.isFinite(now) ? now : 0, messages };
+}
+
+/* Pozitif gecikme saati geri alır (hoparlör geç kalıyorsa ışık bekler).
+ Negatif gecikme saati öne alır. Vuruş numarası değişmez; yalnız faz kayar. */
+function phaseShift(phase, bpm, latencyMs) {
+ let p = Number(phase);
+ if (!Number.isFinite(p)) return 0;
+ p = ((p % 1) + 1) % 1;
+ if (!latencyMs || !Number.isFinite(bpm) || bpm <= 0) return p;
+ p -= latencyMs / (60000 / bpm);
+ return ((p % 1) + 1) % 1;
+}
+
+// ----------------------------------------------------------------- plan
+class Planner {
+ constructor() { this.reset(); }
+
+ reset() {
+ this.levelsDue = -Infinity;
+ this.clockDue = -Infinity;
+ this.bpm = null;
+ this.bpmAt = -Infinity;
+ this.stateAt = -Infinity;
+ this.state = {};
+ for (const k of STATE_KEYS) this.state[k] = '';
+ this.hitOpen = { kick: 0, snare: 0, hat: 0 };
+ this.downbeat = false;
+ this.transport = '';
+ this.transportAt = -Infinity;
+ this.timeline = null;
+ this.timelineAt = -Infinity;
+ this.silent = false;
+ this.quietAt = -Infinity;
+ this.colors = null;
+ this.show = {};
+ this.layerCount = 0;
+ this.layerSig = null;
+ this.deckSig = null;
+ }
+
+ frame(o, frame, ctx, now) {
+ const out = [];
+ const f = frame || {};
+ const c = ctx || {};
+ this._levels(out, o, f, now);
+ this._hits(out, o, f.hits, now);
+ this._clock(out, o, c, now);
+ this._silence(out, o, f, now);
+ this._state(out, o, f, c, now);
+ return out;
+ }
+
+ /* Çizim karesinin gördüğü vuruş. Ölçer iletisine binmez. */
+ hits(o, hits, now) {
+ const out = [];
+ this._hits(out, o, hits, now);
+ return out;
+ }
+
+ /* Panelin tempo motoru: faz, çalma ve gösteri durumu. Sahne adlarını
+ silmez; onlar ölçer bağlamından gelir. */
+ clock(o, info, now) {
+ const out = [];
+ const i = info && typeof info === 'object' ? info : {};
+ this._clock(out, o, i, now);
+ if (i.show && typeof i.show === 'object') {
+ const repeat = now - this.stateAt >= STATE_REPEAT_MS;
+ if (repeat) this.stateAt = now;
+ this._show(out, o, {}, i, now, repeat);
+ }
+ return out;
+ }
+
+ beat(o, info, now) {
+ if (!o.tempo || !info || typeof info !== 'object') return [];
+ const n = clamp(int32(info.beatsPerBar) || 4, 1, 64);
+ const b = int32(info.beat);
+ if (b < 1 || b > n) return [];
+ const p = o.prefix;
+ const messages = [[p + '/tempo/beat', [['i', b], ['i', n]]]];
+ if (b === 1) {
+ messages.push([p + '/tempo/downbeat', [['f', 1]]]);
+ this.downbeat = true;
+ }
+ const item = asBundle(now, messages);
+ return item ? [item] : [];
+ }
+
+ _due(now, slot, period) {
+ if (now < this[slot]) return false;
+ this[slot] = (this[slot] < now - period ? now : this[slot]) + period;
+ return true;
+ }
+
+ _levels(out, o, f, now) {
+ const want = o.levels || o.analysis;
+ if (!want || !this._due(now, 'levelsDue', 1000 / o.rate)) return;
+ const p = o.prefix;
+ const messages = [];
+ if (o.levels) {
+ for (const k of ['level', 'bass', 'mid', 'treble']) messages.push([p + '/' + k, [['f', unit(f[k])]]]);
+ }
+ if (o.analysis && f.analysis && typeof f.analysis === 'object') {
+ const a = f.analysis;
+ for (const k of ANALYSIS_F) messages.push([p + '/analysis/' + k, [['f', unit(a[k])]]]);
+ messages.push([p + '/analysis/correlation', [['f', clamp(finite(a.correlation), -1, 1)]]]);
+ messages.push([p + '/analysis/pitch', [['f', finite(a.pitchHz)]]]);
+ messages.push([p + '/analysis/pitch/note', [['s', a.pitchNote || '']]]);
+ messages.push([p + '/analysis/pitch/confidence', [['f', unit(a.pitchConfidence)]]]);
+ messages.push([p + '/analysis/key', [['s', a.key || '']]]);
+ messages.push([p + '/analysis/key/confidence', [['f', unit(a.keyConfidence)]]]);
+ messages.push([p + '/analysis/chord', [['s', a.chord || '']]]);
+ messages.push([p + '/analysis/chord/confidence', [['f', unit(a.chordConfidence)]]]);
+ }
+ if (o.analysis && Array.isArray(f.spectrum) && f.spectrum.length) {
+ const bands = f.spectrum.slice(0, 32).map((v) => ['f', unit(v)]);
+ messages.push([p + '/spectrum', bands]);
+ }
+ const item = asBundle(now, messages);
+ if (item) out.push(item);
+ }
+
+ _hits(out, o, hits, now) {
+ if (!o.hits || !hits || typeof hits !== 'object') return;
+ const p = o.prefix;
+ const messages = [];
+ for (const k of ['kick', 'snare', 'hat']) {
+ const v = unit(hits[k]);
+ if (v > 0) {
+ messages.push([p + '/hit/' + k, [['f', v]]]);
+ this.hitOpen[k] = v;
+ } else if (this.hitOpen[k] > 0) {
+ messages.push([p + '/hit/' + k, [['f', 0]]]);
+ this.hitOpen[k] = 0;
+ }
+ }
+ const item = asBundle(now, messages);
+ if (item) out.push(item);
+ }
+
+ _clock(out, o, c, now) {
+ if (!o.tempo) return;
+ const p = o.prefix;
+ const messages = [];
+ if (Number.isFinite(c.bpm) && c.bpm > 0) {
+ if (this.bpm === null || Math.abs(c.bpm - this.bpm) >= BPM_STEP || now - this.bpmAt >= HEARTBEAT_MS) {
+ this.bpm = c.bpm;
+ this.bpmAt = now;
+ messages.push([p + '/tempo/bpm', [['f', c.bpm]]]);
+ messages.push([p + '/tempo/confidence', [['f', unit(c.confidence)]]]);
+ }
+ }
+ const phaseDue = Number.isFinite(c.phase) && this._due(now, 'clockDue', 1000 / o.rate);
+ if (phaseDue) {
+ const phase = phaseShift(c.phase, c.bpm || this.bpm, o.latencyMs);
+ const n = clamp(int32(c.beatsPerBar) || 4, 1, 64);
+ const b = int32(c.beat);
+ const bar = b >= 1 && b <= n ? ((b - 1) + phase) / n : phase / n;
+ messages.push([p + '/tempo/beat/phase', [['f', phase]]]);
+ messages.push([p + '/tempo/bar/phase', [['f', bar]]]);
+ }
+ if (this.downbeat) {
+ messages.push([p + '/tempo/downbeat', [['f', 0]]]);
+ this.downbeat = false;
+ }
+ if (typeof c.playing === 'boolean') {
+ const s = c.playing ? 'playing' : 'stopped';
+ if (s !== this.transport || now - this.transportAt >= HEARTBEAT_MS) {
+ this.transport = s;
+ this.transportAt = now;
+ messages.push([p + '/transport', [['s', s]]]);
+ }
+ }
+ if (c.show && typeof c.show.timeline === 'boolean') {
+ const on = c.show.timeline ? 1 : 0;
+ if (on !== this.timeline || now - this.timelineAt >= HEARTBEAT_MS) {
+ this.timeline = on;
+ this.timelineAt = now;
+ messages.push([p + '/timeline/playing', [['i', on]]]);
+ }
+ }
+ const item = asBundle(now, messages);
+ if (item) out.push(item);
+ }
+
+ _silence(out, o, f, now) {
+ if (!o.levels || !Number.isFinite(f.level)) return;
+ const p = o.prefix;
+ if (unit(f.level) < SILENCE_LEVEL) {
+ if (this.quietAt < 0) this.quietAt = now;
+ if (!this.silent && now - this.quietAt >= SILENCE_HOLD_MS) {
+ this.silent = true;
+ out.push([p + '/silence', [['i', 1]]]);
+ }
+ } else if (this.silent || this.quietAt >= 0) {
+ const was = this.silent;
+ this.silent = false;
+ this.quietAt = -Infinity;
+ if (was) out.push([p + '/silence', [['i', 0]]]);
+ }
+ }
+
+ _state(out, o, f, c, now) {
+ if (!o.state) return;
+ const repeat = now - this.stateAt >= STATE_REPEAT_MS;
+ if (repeat) this.stateAt = now;
+ this._names(out, o, f, c, now, repeat);
+ this._colors(out, o, f, c, now, repeat);
+ this._show(out, o, f, c, now, repeat);
+ }
+
+ _names(out, o, f, c, now, repeat) {
+ const p = o.prefix;
+ const md = f.mdPreset && typeof f.mdPreset === 'object' ? f.mdPreset.name : '';
+ const cur = {
+ scene: c.scene,
+ visualizer: c.visualizer,
+ background: c.background,
+ 'milkdrop/preset': md,
+ };
+ const messages = [];
+ for (const k of STATE_KEYS) {
+ if (typeof cur[k] !== 'string') continue;
+ const v = cur[k];
+ // Boş preset de beş saniyede bir yinelenir: geç açılan alıcı "yok"u duyar.
+ if (v !== this.state[k] || repeat) {
+ this.state[k] = v;
+ messages.push([p + '/' + k, [['s', v]]]);
+ }
+ }
+ const item = asBundle(now, messages);
+ if (item) out.push(item);
+ }
+
+ _colors(out, o, f, c, now, repeat) {
+ const fromFrame = Array.isArray(f.backgroundColors) ? f.backgroundColors : null;
+ const fromCfg = Array.isArray(c.colors) ? c.colors : null;
+ const colors = (fromFrame && fromFrame.length ? fromFrame : fromCfg) || [];
+ const sig = colors.slice(0, 8).map((x) => (typeof x === 'string' ? x : '')).join('|');
+ if (this.colors === null && !sig) { this.colors = ''; return; }
+ if (sig === this.colors && !(repeat && sig)) return;
+ this.colors = sig;
+ const p = o.prefix;
+ const messages = [];
+ const n = Math.min(8, colors.length);
+ for (let i = 0; i < n; i++) messages.push([p + '/background/color/' + (i + 1), [['s', String(colors[i] || '')]]]);
+ if (!n && this.colors === '') messages.push([p + '/background/color/1', [['s', '']]]);
+ const item = asBundle(now, messages);
+ if (item) out.push(item);
+ }
+
+ _show(out, o, f, c, now, repeat) {
+ if (!o.state) return;
+ const show = c.show && typeof c.show === 'object' ? c.show : null;
+ if (!show) return;
+ const p = o.prefix;
+ const messages = [];
+ const put = (key, address, args) => {
+ const sig = JSON.stringify(args);
+ if (this.show[key] === sig && !repeat) return;
+ this.show[key] = sig;
+ messages.push([address, args]);
+ };
+ if (typeof show.blackout === 'boolean') put('blackout', p + '/show/blackout', [['i', show.blackout ? 1 : 0]]);
+ if (typeof show.palette === 'string') put('palette', p + '/show/palette', [['s', show.palette]]);
+ if (Number.isFinite(show.brightness)) put('brightness', p + '/show/brightness', [['f', show.brightness]]);
+ if (typeof show.transition === 'string') put('transition', p + '/show/transition', [['s', show.transition]]);
+ if (typeof show.autovj === 'boolean') put('autovj', p + '/show/autovj', [['i', show.autovj ? 1 : 0]]);
+ if (typeof show.track === 'string') put('track', p + '/show/track', [['s', show.track]]);
+ if (Array.isArray(show.layers)) {
+ const layers = show.layers.slice(0, 32).map((l) => ({
+ name: l && typeof l.name === 'string' ? l.name : '',
+ opacity: l && Number.isFinite(Number(l.opacity)) ? unit(Number(l.opacity)) : 1,
+ enabled: !(l && l.enabled === false),
+ }));
+ const sig = JSON.stringify(layers);
+ if (sig !== this.layerSig || repeat) {
+ this.layerSig = sig;
+ messages.push([p + '/layer/count', [['i', layers.length]]]);
+ for (let i = 0; i < layers.length; i++) {
+ const n = i + 1;
+ messages.push([p + '/layer/' + n + '/name', [['s', layers[i].name]]]);
+ messages.push([p + '/layer/' + n + '/opacity', [['f', layers[i].opacity]]]);
+ messages.push([p + '/layer/' + n + '/enabled', [['i', layers[i].enabled ? 1 : 0]]]);
+ }
+ for (let i = layers.length; i < this.layerCount; i++) {
+ const n = i + 1;
+ messages.push([p + '/layer/' + n + '/opacity', [['f', 0]]]);
+ messages.push([p + '/layer/' + n + '/enabled', [['i', 0]]]);
+ }
+ this.layerCount = layers.length;
+ }
+ }
+ if (show.deck && typeof show.deck === 'object') {
+ const row = int32(show.deck.row);
+ const col = int32(show.deck.col);
+ const active = typeof show.deck.active === 'string' ? show.deck.active : '';
+ const sig = row + ':' + col + ':' + active;
+ if (sig !== this.deckSig || repeat) {
+ this.deckSig = sig;
+ messages.push([p + '/deck/row', [['i', row]]]);
+ messages.push([p + '/deck/col', [['i', col]]]);
+ messages.push([p + '/deck/active', [['s', active]]]);
+ }
+ }
+ if (Number.isFinite(show.opacity)) put('opacity', p + '/show/opacity', [['f', clamp(show.opacity, 0, 1)]]);
+ if (Number.isFinite(show.crossfade)) put('crossfade', p + '/crossfade', [['f', clamp(show.crossfade, 0, 1)]]);
+ if (Array.isArray(show.controls)) {
+ for (const c of show.controls) {
+ if (!c || typeof c.path !== 'string' || !Number.isFinite(Number(c.value))) continue;
+ const addr = p + '/' + c.path.replace(/\./g, '/');
+ if (c.int) put('c:' + c.path, addr, [['i', int32(c.value)]]);
+ else put('c:' + c.path, addr, [['f', Number(c.value)]]);
+ }
+ }
+ const item = asBundle(now, messages);
+ if (item) out.push(item);
+ }
+}
+
+// --------------------------------------------------------- geri besleme
+function ipKey(addr) {
+ return String(addr || '').split('%')[0].toLowerCase();
+}
+
+function isLocalAddress(addr) {
+ if (typeof addr !== 'string' || !addr) return false;
+ const key = ipKey(addr);
+ if (key === 'localhost' || key === '0.0.0.0' || key === '255.255.255.255' || key === '::' || key === '::1') return true;
+ if (/^127\./.test(key)) return true;
+ const ifs = os.networkInterfaces();
+ for (const name of Object.keys(ifs)) {
+ for (const a of ifs[name] || []) {
+ if (!a) continue;
+ const family = a.family === 4 || a.family === 'IPv4' ? 4 : (a.family === 6 || a.family === 'IPv6' ? 6 : 0);
+ if (family === 4) {
+ if (a.address === addr) return true;
+ if (a.netmask && net.isIPv4(a.address) && net.isIPv4(a.netmask)) {
+ const ip = a.address.split('.').map(Number);
+ const mask = a.netmask.split('.').map(Number);
+ if (ip.map((x, i) => (x | (~mask[i] & 255))).join('.') === addr) return true;
+ }
+ } else if (family === 6 && ipKey(a.address) === key) return true;
+ }
+ }
+ return false;
+}
+
+function loopError(o, address, oscIn) {
+ if (!oscIn || oscIn.enabled !== true || Number(oscIn.port) !== o.port) return null;
+ return isLocalAddress(address || o.host) ? LOOP : null;
+}
+
+// ---------------------------------------------------------------- soket
+let sockets = [];
+let live = [];
+let started = '';
+let startGen = 0;
+const planner = new Planner();
+let state = { running: false, host: '', address: '', port: 0, targets: 0, packets: 0, lastSend: 0, error: null };
+let holdTimer = null;
+
+function familyOf(address) {
+ return net.isIPv6(address) ? 6 : 4;
+}
+
+function resolveHost(host) {
+ if (net.isIPv4(host)) return Promise.resolve({ address: host, family: 4 });
+ if (net.isIPv6(host)) return Promise.resolve({ address: host, family: 6 });
+ if (host === 'localhost') return Promise.resolve({ address: '127.0.0.1', family: 4 });
+ return new Promise((resolve, reject) => {
+ dns.lookup(host, { verbatim: true }, (err, address) => (err ? reject(err) : resolve({ address, family: familyOf(address) })));
+ });
+}
+
+function openSocket(family) {
+ return new Promise((resolve) => {
+ const s = dgram.createSocket({ type: family === 6 ? 'udp6' : 'udp4' });
+ const fail = (err) => {
+ state.error = (err && (err.code || err.message)) || 'socket';
+ try { s.close(); } catch { /* zaten kapalı */ }
+ resolve(null);
+ };
+ s.once('error', fail);
+ s.bind(() => {
+ s.removeListener('error', fail);
+ s.on('error', (err) => { state.error = err.code || err.message; });
+ if (family === 4) { try { s.setBroadcast(true); } catch { /* yayın yoksa tek adrese devam */ } }
+ resolve(s);
+ });
+ });
+}
+
+function closeSockets() {
+ const list = sockets;
+ sockets = [];
+ live = [];
+ for (const s of list) {
+ try { s.close(); } catch { /* zaten kapalı */ }
+ }
+}
+
+function start(cfg, oscIn) {
+ const o = normalize(cfg);
+ if (!o.enabled) return stop().then(status);
+ const wanted = targetsOf(o);
+ const key = wanted.map((t) => t.host + ':' + t.port).join('|');
+ if (sockets.length && state.running && started === key) {
+ live.forEach((t) => { t.loop = loopError({ port: t.port }, t.address, oscIn) === LOOP; });
+ const usable = live.filter((t) => !t.loop);
+ state.error = usable.length ? null : LOOP;
+ state.targets = live.length;
+ return Promise.resolve(status());
+ }
+ const gen = ++startGen;
+ return stop({ keepGen: true }).then(() => {
+ if (gen !== startGen) return status();
+ return Promise.all(wanted.map((t) => resolveHost(t.host).then((r) => Object.assign({}, t, r)).catch((err) => ({ error: err }))))
+ .then((resolved) => {
+ if (gen !== startGen) return status();
+ const ok = resolved.filter((t) => t.address);
+ if (!ok.length) {
+ const err = resolved[0] && resolved[0].error;
+ state = { running: false, host: o.host, address: '', port: o.port, targets: 0, packets: 0, lastSend: 0, error: (err && (err.code || err.message)) || 'resolve' };
+ return status();
+ }
+ const families = [...new Set(ok.map((t) => t.family))];
+ return Promise.all(families.map((f) => openSocket(f).then((s) => [f, s]))).then((pairs) => {
+ if (gen !== startGen) {
+ for (const [, s] of pairs) if (s) { try { s.close(); } catch { /* kapanan deneme */ } }
+ return status();
+ }
+ sockets = pairs.filter(([, s]) => s).map(([, s]) => s);
+ const byFamily = {};
+ pairs.forEach(([f, s]) => { if (s) byFamily[f] = s; });
+ live = ok.filter((t) => byFamily[t.family]).map((t) => ({
+ address: t.address,
+ port: t.port,
+ family: t.family,
+ socket: byFamily[t.family],
+ loop: loopError({ port: t.port }, t.address, oscIn) === LOOP,
+ }));
+ started = key;
+ planner.reset();
+ const usable = live.filter((t) => !t.loop);
+ const first = live[0];
+ state = {
+ running: true,
+ host: o.host,
+ address: first ? first.address : '',
+ port: o.port,
+ targets: live.length,
+ packets: 0,
+ lastSend: 0,
+ error: usable.length ? null : LOOP,
+ };
+ return status();
+ });
+ });
+ });
+}
+
+function stop(opts) {
+ if (!opts || !opts.keepGen) startGen++;
+ if (holdTimer) { clearTimeout(holdTimer); holdTimer = null; }
+ state.running = false;
+ started = '';
+ closeSockets();
+ return Promise.resolve();
+}
+
+function datagram(item) {
+ if (item && item.bundle) return encodeBundle(item.messages, item.time);
+ if (Array.isArray(item)) return encodeMessage(item[0], item[1]);
+ return null;
+}
+
+function emitNow(items) {
+ const targets = live.filter((t) => !t.loop && t.socket);
+ if (!targets.length) return 0;
+ let n = 0;
+ for (const item of items) {
+ const buf = datagram(item);
+ if (!buf) continue;
+ for (const t of targets) {
+ try {
+ t.socket.send(buf, t.port, t.address, (err) => {
+ if (err) state.error = err.code || err.message;
+ else {
+ state.packets++;
+ state.lastSend = Date.now();
+ }
+ });
+ n++;
+ } catch (err) {
+ state.error = err.message;
+ }
+ }
+ }
+ return n;
+}
+
+function emit(o, items) {
+ if (!items.length) return 0;
+ const delay = Math.max(0, o.latencyMs || 0);
+ if (!delay) return emitNow(items);
+ holdTimer = setTimeout(() => {
+ holdTimer = null;
+ if (state.running) emitNow(items);
+ }, delay);
+ return items.length * Math.max(1, live.filter((t) => !t.loop).length);
+}
+
+function ready(cfg) {
+ if (!sockets.length || !state.running || state.error === LOOP) return null;
+ const o = normalize(cfg);
+ return o.enabled ? o : null;
+}
+
+function send(cfg, frame, ctx) {
+ const o = ready(cfg);
+ return o ? emit(o, planner.frame(o, frame, ctx, Date.now())) : 0;
+}
+
+function beat(cfg, info) {
+ const o = ready(cfg);
+ return o ? emit(o, planner.beat(o, info, Date.now())) : 0;
+}
+
+function hit(cfg, hits) {
+ const o = ready(cfg);
+ return o ? emit(o, planner.hits(o, hits, Date.now())) : 0;
+}
+
+function clock(cfg, info) {
+ const o = ready(cfg);
+ const when = info && Number.isFinite(info.hostTime) ? info.hostTime : Date.now();
+ return o ? emit(o, planner.clock(o, info, when)) : 0;
+}
+
+function status() {
+ return Object.assign({}, state);
+}
+
+module.exports = {
+ start, stop, send, beat, hit, clock, status,
+ normalize, encodeMessage, encodeBundle, oscString, ntpTimetag, phaseShift,
+ Planner, isLocalAddress, loopError, targetsOf, validHost, controlValues, CONTROL_PATHS,
+ DEFAULTS, LOOP, NTP_UNIX,
+};
diff --git a/src/main/osc-server.js b/src/main/osc-server.js
index d0b198e3..cb2b8602 100644
--- a/src/main/osc-server.js
+++ b/src/main/osc-server.js
@@ -148,4 +148,5 @@ function status() {
return Object.assign({}, state);
}
-module.exports = { start, stop, status };
+// parsePacket testler için: OSC çıkışının ürettiği paketler bununla çözülüyor (#437)
+module.exports = { start, stop, status, parsePacket };
diff --git a/src/main/preload-admin.js b/src/main/preload-admin.js
index 31aea040..486a970c 100644
--- a/src/main/preload-admin.js
+++ b/src/main/preload-admin.js
@@ -180,6 +180,12 @@ contextBridge.exposeInMainWorld('api', {
oscSync: () => ipcRenderer.invoke('osc:sync'),
onOscMessage: (cb) => ipcRenderer.on('osc-message', (e, m) => cb(m)),
onOscStatus: (cb) => ipcRenderer.on('osc-status', (e, d) => cb(d)),
+ // OSC çıkışı (#437)
+ oscOutStatus: () => ipcRenderer.invoke('oscout:status'),
+ oscOutSync: () => ipcRenderer.invoke('oscout:sync'),
+ onOscOutStatus: (cb) => ipcRenderer.on('oscout-status', (e, d) => cb(d)),
+ reportTempoBeat: (info) => ipcRenderer.send('tempo:beat', info),
+ reportTempoClock: (info) => ipcRenderer.send('tempo:clock', info),
// Güncelleme denetimi (#640)
updatesState: () => ipcRenderer.invoke('updates:state'),
diff --git a/src/main/preload-visualizer.js b/src/main/preload-visualizer.js
index 7670f94c..5d2939d6 100644
--- a/src/main/preload-visualizer.js
+++ b/src/main/preload-visualizer.js
@@ -63,6 +63,7 @@ contextBridge.exposeInMainWorld('api', {
nowPlayingCurrent: () => ipcRenderer.invoke('nowplaying:current'),
onNativeAudio: (cb) => ipcRenderer.on('native-audio', (e, frame) => cb(frame)),
sendAudioMeter: (data) => ipcRenderer.send('audio-meter', data),
+ sendOscHit: (hits) => ipcRenderer.send('osc-hit', hits),
sendMessage: (msg) => ipcRenderer.send('visualizer-message', msg),
claimCamRelay: (key) => ipcRenderer.invoke('cam-relay-claim', key),
releaseCamRelay: (key) => ipcRenderer.send('cam-relay-release', key),
diff --git a/src/shared/defaults.js b/src/shared/defaults.js
index bf09186b..e53affd2 100644
--- a/src/shared/defaults.js
+++ b/src/shared/defaults.js
@@ -250,6 +250,7 @@
gap: 0.36, // barlar arası boşluk oranı
position: 'center', // 'bottom' | 'center' | 'full' (bars için)
thickness: 0.42, // dalga/çember için
+ trailHeight: 1, // Stereo İzler tepe çarpanı; 1 bugünkü yükseklik
/* Bar yerleşimi (yayın/müzik videosu düzenleri için).
null = eski davranış: tam genişlik, position alanının verdiği taban
@@ -1057,6 +1058,26 @@
fps: 30, // DMX zaten 44 Hz üstünü taşımaz
},
+ // ------------------------------------------------------------------
+ // OSC çıkışı (#437): ses seviyeleri, vuruşlar, tempo ve sahne/mod
+ // değişimleri başka yazılımlara (Resolume, TouchDesigner, ışık masası).
+ // Varsayılan kapalı ve hedef bu bilgisayar. Adresler src/main/osc-out.js.
+ // ------------------------------------------------------------------
+ oscOut: {
+ enabled: false,
+ host: '127.0.0.1',
+ port: 9001, // OSC girişi 9000'de; aynı port geri besleme olurdu
+ rate: 30, // seviye iletileri, Hz (en çok 30: ölçer bu hızda)
+ prefix: '/cayadev',
+ levels: true,
+ hits: true,
+ tempo: true,
+ state: true,
+ analysis: true, // tayf, perde, akor ve 16 bant
+ latencyMs: 0, // pozitif: saat geri kalır (geç hoparlör)
+ extra: '', // ek hedefler, satır başına host:port ya da [ipv6]:port
+ },
+
// ------------------------------------------------------------------
// Harici kontrol yüzeyleri (MIDI / OSC)
// Eşleme: { id, source:'midi'|'osc', channel, cc, address, path, min, max, mode }
diff --git a/src/shared/i18n.js b/src/shared/i18n.js
index b70e27ad..c7479d46 100644
--- a/src/shared/i18n.js
+++ b/src/shared/i18n.js
@@ -559,6 +559,7 @@
'Kardioid': 'Cardioid',
'Vuruş Pedleri': 'Beat Pads',
'Zıplayan Toplar': 'Bouncing Balls',
+ 'Stereo İzler': 'Stereo Trails',
'Seviye Ölçer (PPM)': 'Level Meter (PPM)',
'Su Altı': 'Underwater',
'Işık Hüzmesi': 'Light Shafts',
@@ -936,6 +937,27 @@
'Bu ortamda Web MIDI kullanılamıyor.': 'Web MIDI is unavailable in this environment.',
'sinyal bekleniyor…': 'waiting for a signal…', 'mesaj bekleniyor…': 'waiting for a message…',
'UDP Portu': 'UDP Port',
+ // OSC çıkışı (#437)
+ 'OSC Çıkışı': 'OSC Output', 'OSC Çıkışı Etkin': 'OSC Output Enabled',
+ 'Ses seviyelerini, davul vuruşlarını, tempoyu ve sahne değişimlerini OSC ile başka yazılımlara gönderin: Resolume, TouchDesigner, Max veya bir ışık masası.':
+ 'Send audio levels, drum hits, tempo and scene changes over OSC to other software: Resolume, TouchDesigner, Max or a lighting desk.',
+ 'Hedef Port': 'Target Port', 'Seviye Gönderim Hızı (Hz)': 'Level Send Rate (Hz)', 'Adres Öneki': 'Address Prefix',
+ 'Ses Seviyeleri': 'Audio Levels', 'Davul Vuruşları': 'Drum Hits',
+ 'Tempo ve Vuruş Saati': 'Tempo and Beat Clock', 'Sahne ve Mod Değişimleri': 'Scene and Mode Changes',
+ 'Gönderiliyor': 'Sending',
+ 'Adres bir IPv4, IPv6 ya da ana bilgisayar adı olmalı.': 'The address must be an IPv4 address, an IPv6 address or a host name.',
+ 'Hız 1–30 arasında bir tam sayı olmalı.': 'The rate must be a whole number from 1 to 30.',
+ 'Gecikme -2000 ile 2000 ms arasında bir tam sayı olmalı.': 'Latency must be a whole number of milliseconds from -2000 to 2000.',
+ 'Önek /cayadev gibi olmalı: en çok dört parça, harf, rakam, - ve _.': 'The prefix must look like /cayadev: up to four parts of letters, digits, - and _.',
+ 'Saat Gecikmesi (ms)': 'Clock Latency (ms)',
+ 'Ek Hedefler': 'Extra Targets',
+ 'Çözümleme ve Tayf': 'Analysis and Spectrum',
+ 'Hedef bu bilgisayarın OSC girişi; geri besleme olmasın diye gönderilmiyor. Portu değiştirin.':
+ 'The target is this computer\'s OSC input, so nothing is sent, to avoid a feedback loop. Change the port.',
+ 'Seviye, bas, mid ve tiz tek pakette gider. Vuruştan sonra 0 gelir. Saat: BPM, faz (0..1), ölçü fazı, ölçü başı, çalıyor ya da durdu. Ayrıntılı adres ağacı README dosyasında.':
+ 'Level, bass, mid and treble travel in one packet. A hit is followed by 0. Clock: BPM, phase (0..1), bar phase, downbeat, playing or stopped. The address tree is in the README.',
+ 'Ek hedefler satır satır: 10.0.0.8:9001 ya da [::1]:9001. Pozitif gecikme saati geri alır; hoparlör geç kalıyorsa ışık onu bekler.':
+ 'Extra targets, one per line: 10.0.0.8:9001 or [::1]:9001. A positive latency delays the clock, so lights wait for a late speaker.',
'OSC gönderen uygulamayı bu bilgisayarın IP adresine ve yukarıdaki porta yöneltin. 0..1 arası değerler doğrudan, 0..127 arası değerler otomatik ölçeklenerek kullanılır.': 'Point the OSC sender at this computer\'s IP address and the port above. Values between 0 and 1 are used directly; values up to 127 are scaled automatically.',
'Henüz eşleme yok. “Eşleme Ekle” ile başlayın.': 'No mappings yet. Start with "Add Mapping".',
'Eşleme Ekle': 'Add Mapping', 'Eşlemeyi kaldır': 'Remove mapping',
@@ -2655,6 +2677,7 @@
'Görselleştirici · Bar Boşluğu': 'Visualizer · Bar Gap',
'Görselleştirici · Çizgi Kalınlığı': 'Visualizer · Line Width',
'Görselleştirici · Genlik': 'Visualizer · Amplitude',
+ 'Görselleştirici · Yükseklik': 'Visualizer · Height',
'Arkaplan · Akış Hızı': 'Background · Flow Speed',
'Arkaplan · Ses Tepkisi': 'Background · Audio Reactivity',
'Arkaplan · Parlaklık': 'Background · Brightness',
diff --git a/src/shared/mcp.js b/src/shared/mcp.js
index 1173b343..0678c6de 100644
--- a/src/shared/mcp.js
+++ b/src/shared/mcp.js
@@ -168,7 +168,7 @@
isBlackout: 'blackout', 'transition.blackoutType': 'blackout', 'transition.blackoutDuration': 'blackout',
export: 'export', recording: 'export',
display: 'output', mapping: 'output', textureShare: 'output', aspect: 'output', floating: 'output',
- power: 'output', lighting: 'output', openrgb: 'output', artnet: 'output',
+ power: 'output', lighting: 'output', openrgb: 'output', artnet: 'output', oscOut: 'output',
'audio.sources': 'output',
'background.transparent': 'output', 'background.coverTaskbar': 'output', 'background.transparentKey': 'output',
postfx: 'effectEdit', modulation: 'effectEdit',
diff --git a/src/shared/mode-catalog.js b/src/shared/mode-catalog.js
index 17a82310..05161666 100644
--- a/src/shared/mode-catalog.js
+++ b/src/shared/mode-catalog.js
@@ -77,6 +77,7 @@
V('confetti', 'Konfeti', 'Parçacık ve Olay', { color2: true }),
V('beatpads', 'Vuruş Pedleri', 'Parçacık ve Olay', { bands: true, gap: true, color2: true }),
V('bounce', 'Zıplayan Toplar', 'Parçacık ve Olay', { bands: true, gap: true, color2: true }),
+ V('stereotrails', 'Stereo İzler', 'Parçacık ve Olay', { bands: true, wave: true, thick: true, color2: true }),
V('flowfield', 'Akış Alanı', 'Üretken Sistemler'),
V('flock', 'Sürü', 'Üretken Sistemler'),
diff --git a/src/shared/stereo-bands.js b/src/shared/stereo-bands.js
new file mode 100644
index 00000000..11b6feca
--- /dev/null
+++ b/src/shared/stereo-bands.js
@@ -0,0 +1,199 @@
+/*
+ * SoundVisualizer — CaYaDev Ses Görselleştirici
+ * Copyright (c) 2026 Çağan Turgut (CaYatur) — CaYaDev, https://cayadev.com
+ * https://github.com/CaYatur/SoundVisualizer
+ * SPDX-License-Identifier: MIT
+ */
+'use strict';
+/* Bant bant stereo görüntü: her frekans bandı sol-sağ eksende NEREDE ve ne
+ kadar DAĞINIK.
+
+ Gonyometre ve analysis.js'in genişlik/korelasyonu tüm sinyali tek sayıya
+ indiriyor. Müzikte bas ve davul genelde ortada, gitar bir yana, hi-hat
+ öbür yana, yankı iki yana yayılır; tek sayı bunların ortalamasını verir ve
+ hepsi "biraz geniş, ortada" görünür. Burada her bant kendi sol ve sağ
+ kanal enerjisinden ölçülüyor, böylece sola kaydırılmış bir enstrüman
+ kendi bandında solda görünür.
+
+ YÖNTEM
+ Her bant, iki kenarı arasında bir bant geçiren süzgeç (RBJ "constant
+ 0 dB peak gain" biquad). Kenarlar verilmezse logaritmik aralıklı; Stereo
+ İzler tayfın kendi kenarlarını veriyor (mel, bark...). İki kanal aynı süzgeçten
+ geçiyor; çıkışlardan üç toplam tutuluyor: ΣL², ΣR², ΣLR.
+ konum (ΣR² − ΣL²) / (ΣR² + ΣL²) -1 tam sol, 0 orta, +1 tam sağ
+ dağınıklık 1 − ΣLR / √(ΣL²·ΣR²), [0,1]'e kırpılır: tek bir kaynak
+ nereye kaydırılmış olursa olsun 0, ilişkisiz iki kanal 1,
+ ters faz da 1
+ seviye √((ΣL² + ΣR²) / 2N), bandın RMS'i
+ Konum enerji oranından geldiği için sabit güçlü bir kaydırmada
+ (gL = cos θ, gR = sin θ) tam sol, orta ve tam sağda kesin; aradaki
+ noktalarda tekdüze artar.
+
+ Dağınıklık BİLEREK analysis.js'in genişliği (2·ΣS²/(ΣM²+ΣS²)) değil. O
+ tanımda tam sola kaydırılmış mono bir gitar ile iki yana yayılmış bir
+ yankı aynı sayıyı (1) alıyor: yalnız soldaki sinyalin orta ve yan
+ enerjisi eşit. Burada konum ile dağınıklık ayrı sorular: gitar "solda,
+ dar", yankı "ortada, dağınık".
+
+ Süzgeç her karede sıfır durumdan, tamponun başından başlıyor: kareler
+ arasında durum taşınmıyor çünkü tampon kayan bir pencere (yeni kare
+ öncekiyle örtüşüyor) ve durum taşımak aynı örnekleri iki kez saymak
+ olurdu. Isınma payı (pencerenin ilk çeyreği) toplamlara katılmıyor.
+
+ Sessizlikte ve nicemleme gürültüsünün altında konum ve dağınıklık 0:
+ 8 bitlik örneklerde ±1 basamaklık gürültünün bir yönü yok, ona bakarak
+ bir yan seçmek yanlış olurdu.
+
+ Ayırma yok: sonuç dizileri configure() ile, tampon boyu değişince de
+ örnek tamponu bir kez ayrılıyor; kare başına update() yalnızca sayı
+ yazar. Saf aritmetik: testleri Node'da koşar. */
+(function () {
+ const clamp = (v, a, b) => (v < a ? a : v > b ? b : v);
+ const MIN_HZ = 25;
+ // RMS bunun altındaysa yön yok: 8 bitte bir basamak 1/128, gürültüsü ~0,002
+ const QUIET_RMS = 0.004;
+
+ /* Logaritmik aralıklı n+1 kenar. Alt kenar 25 Hz'den, üst kenar
+ Nyquist'in %45'inden öteye geçmez: süzgeç tasarımı Nyquist'e yakın
+ bozuluyor. */
+ function bandEdges(n, minHz, maxHz, sampleRate) {
+ const lo = Math.max(MIN_HZ, minHz || MIN_HZ);
+ const hi = Math.max(lo * 1.5, Math.min(maxHz || 20000, sampleRate * 0.45));
+ const out = new Float64Array(n + 1);
+ const r = Math.log(hi / lo);
+ for (let i = 0; i <= n; i++) out[i] = lo * Math.exp((r * i) / n);
+ return out;
+ }
+
+ /* Dışarıdan verilen kenarlar (ör. SVSpectrum.bandEdges'in mel ya da bark
+ ölçeği) aynı sınırlara çekiliyor. Her bant en az %5 genişlikte kalır:
+ iki kenar sınırda üst üste düşerse Q sonsuza gider. */
+ function fitEdges(edges, sampleRate) {
+ const n = edges.length - 1;
+ const out = new Float64Array(n + 1);
+ const top = sampleRate * 0.45;
+ for (let i = 0; i <= n; i++) {
+ const prev = i ? out[i - 1] * 1.05 : MIN_HZ;
+ out[i] = Math.max(prev, clamp(edges[i], MIN_HZ, top));
+ }
+ return out;
+ }
+
+ /* RBJ bant geçiren, tepe kazancı 0 dB. b1 = 0 ve b2 = -b0 olduğu için
+ yalnız üç katsayı tutuluyor. Merkez kenarların geometrik ortası, Q bant
+ genişliğinden. */
+ function bandpass(f0, q, sampleRate) {
+ const w = (2 * Math.PI * f0) / sampleRate;
+ const alpha = Math.sin(w) / (2 * q);
+ const a0 = 1 + alpha;
+ return { b0: alpha / a0, a1: (-2 * Math.cos(w)) / a0, a2: (1 - alpha) / a0 };
+ }
+
+ class StereoBands {
+ constructor() {
+ this.n = 0;
+ this.edges = null;
+ this.pan = null; // -1..1
+ this.spread = null; // 0..1
+ this.level = null; // bandın RMS'i, tam ölçekli sinüste ~0,7
+ this._b0 = null;
+ this._a1 = null;
+ this._a2 = null;
+ this._l = null;
+ this._r = null;
+ }
+
+ /* Ayar değişince çağrılır (her karede değil: dizileri yeniden ayırır).
+ `edges` verilirse (n+1 kenar) bantlar onlardan, verilmezse
+ minHz..maxHz arası logaritmik. */
+ configure(n, minHz, maxHz, sampleRate, edges) {
+ n = clamp(n | 0, 1, 32);
+ const sr = sampleRate || 48000;
+ this.n = n;
+ this.edges = edges && edges.length === n + 1 ? fitEdges(edges, sr) : bandEdges(n, minHz, maxHz, sr);
+ this.pan = new Float32Array(n);
+ this.spread = new Float32Array(n);
+ this.level = new Float32Array(n);
+ this._b0 = new Float64Array(n);
+ this._a1 = new Float64Array(n);
+ this._a2 = new Float64Array(n);
+ for (let k = 0; k < n; k++) {
+ const lo = this.edges[k];
+ const hi = this.edges[k + 1];
+ const f0 = Math.sqrt(lo * hi);
+ const c = bandpass(f0, f0 / (hi - lo), sr);
+ this._b0[k] = c.b0;
+ this._a1[k] = c.a1;
+ this._a2[k] = c.a2;
+ }
+ }
+
+ /* left / right: aynı boyda örnek dizileri. `center` 8 bitlik baytlar
+ için 128 (görselleştiricinin timeL/timeR'ı), -1..1 kayan noktalı
+ diziler için 0. Kanallardan biri yoksa ya da boylar farklıysa her
+ şey sıfırlanır. */
+ update(left, right, center) {
+ const n = this.n;
+ if (!n) return this;
+ const N = left && right && left.length === right.length ? left.length : 0;
+ if (N < 8) {
+ this.pan.fill(0);
+ this.spread.fill(0);
+ this.level.fill(0);
+ return this;
+ }
+ if (!this._l || this._l.length !== N) {
+ this._l = new Float32Array(N);
+ this._r = new Float32Array(N);
+ }
+ const c0 = center || 0;
+ const scale = c0 ? 1 / c0 : 1;
+ const L = this._l;
+ const R = this._r;
+ for (let i = 0; i < N; i++) {
+ L[i] = (left[i] - c0) * scale;
+ R[i] = (right[i] - c0) * scale;
+ }
+ const warm = N >> 2;
+ const count = N - warm;
+ for (let k = 0; k < n; k++) {
+ const b0 = this._b0[k];
+ const a1 = this._a1[k];
+ const a2 = this._a2[k];
+ let xl1 = 0, xl2 = 0, yl1 = 0, yl2 = 0;
+ let xr1 = 0, xr2 = 0, yr1 = 0, yr2 = 0;
+ let sll = 0, srr = 0, slr = 0;
+ for (let i = 0; i < N; i++) {
+ const xl = L[i];
+ const xr = R[i];
+ const yl = b0 * (xl - xl2) - a1 * yl1 - a2 * yl2;
+ const yr = b0 * (xr - xr2) - a1 * yr1 - a2 * yr2;
+ xl2 = xl1; xl1 = xl; yl2 = yl1; yl1 = yl;
+ xr2 = xr1; xr1 = xr; yr2 = yr1; yr1 = yr;
+ if (i >= warm) {
+ sll += yl * yl;
+ srr += yr * yr;
+ slr += yl * yr;
+ }
+ }
+ const tot = sll + srr;
+ const rms = Math.sqrt(tot / (2 * count));
+ this.level[k] = rms;
+ if (rms < QUIET_RMS) {
+ this.pan[k] = 0;
+ this.spread[k] = 0;
+ continue;
+ }
+ this.pan[k] = clamp((srr - sll) / tot, -1, 1);
+ // Tek kanalda enerji yoksa kaynak tek noktada: korelasyon 1 sayılır
+ const den = Math.sqrt(sll * srr);
+ this.spread[k] = den > tot * 1e-6 ? clamp(1 - slr / den, 0, 1) : 0;
+ }
+ return this;
+ }
+ }
+
+ const api = { StereoBands, bandEdges, fitEdges, bandpass, QUIET_RMS };
+ if (typeof module !== 'undefined' && module.exports) module.exports = api;
+ if (typeof window !== 'undefined') window.SVStereoBands = api;
+})();
diff --git a/src/visualizer/index.html b/src/visualizer/index.html
index 8ebeae3f..236e0942 100644
--- a/src/visualizer/index.html
+++ b/src/visualizer/index.html
@@ -69,6 +69,7 @@
+
diff --git a/src/visualizer/modes/generative2.js b/src/visualizer/modes/generative2.js
index 95982ca8..d043cce4 100644
--- a/src/visualizer/modes/generative2.js
+++ b/src/visualizer/modes/generative2.js
@@ -968,6 +968,222 @@
dispose() { this.n = 0; }
}
+ // ==========================================================================
+ // STEREO İZLER — her bant stereo görüntüdeki yerinden fışkırır
+ // ==========================================================================
+ /* Tabanda bir çeşme. Her frekans bandı kendi parçacıklarını atıyor:
+ fırlatma açısı bandın sol-sağ konumundan, saçılması dağınıklığından
+ (SVStereoBands), sayısı ve hızı bandın seviyesinden. Ortada miksli bir
+ davul dik bir sütun çizer, sola kaydırılmış bir gitar kendi yaylarını
+ sola eğer, iki yana yayılmış bir yankı yelpaze gibi açılır. Mono
+ kaynakta her şey dik çıkar; ölçüm de bunu söylüyor.
+
+ Seviye getBars'tan: bar sayısı, frekans aralığı ve Tayf Ölçümü
+ ayarlarının hepsi bu modda da işliyor. Stereo ölçüm aynı bant
+ kenarlarıyla yapılıyor (SVSpectrum.bandEdges), yoksa mel ya da bark
+ ölçeğinde seviye ile konum farklı bantlardan gelirdi.
+
+ Renk ve boy banda göre: bas birincil renkte, iri ve alçak; tiz ikincil
+ renkte, ince ve yüksek. Konum ve dağınıklık yumuşatılıyor: kısa bir
+ pencerede dar bir bandın ölçümü kare kare titriyor, çeşme savrulurdu.
+
+ Konum açıya eğriyle çevriliyor (|p|^0,6): müzikte bantların çoğu
+ ortaya yakın (önizlemenin örnek sesinde ±0,05..0,25), doğrusal eşlemede
+ ince bir stereo görüntü hiç eğilmiyordu. Uçlar yine tam sol ve tam sağ.
+ Çizim 'lighter' değil source-over: toplamalı karışım varsayılan açık
+ arkaplanda soluklaşıp kayboluyordu; ışıma SVGlow'dan geliyor. Çizgi
+ uçları 'butt': segmentler uç uca eklendiği için yuvarlak uç görünmüyor
+ ama her karede yüzlerce segmentte maliyeti var (Iris Xe, 1080p,
+ kilitsiz bench: yuvarlakla 118 ve 92 kare/sn, butt ile 124 ve 118).
+
+ Sabit havuz, halka sırasıyla en eskisinin üstüne yazılır. Çizim
+ bant × (yükselen/düşen) kovasına sayma sıralamasıyla gruplanıyor, kova
+ başına tek stroke. Kare başına dizi ayrılmıyor. */
+ const ST_POOL = 1800;
+ const ST_GRAVITY = 1.6; // yükseklik birimi (H) / sn²
+ const ST_TILT = 0.95; // tam sol/sağda dikeyden sapma (rad, ~54°)
+ const ST_SCATTER = 1.4; // tam dağınık bantta ek saçılma aralığı (rad)
+ const ST_CURVE = 0.6; // konumdan açıya eğri üssü
+
+ class StereoTrails {
+ constructor(canvas) {
+ this.canvas = canvas;
+ this.ctx = canvas.getContext('2d');
+ this.glow = new window.SVGlow();
+ this.rand = rng(0x5e7e0);
+ this.onset = onset(0.15);
+ this.sb = window.SVStereoBands ? new window.SVStereoBands.StereoBands() : null;
+ this.sbKey = '';
+ // Konum H biriminde: x tabanın ortasından, y tabandan yukarı
+ this.px = new Float32Array(ST_POOL);
+ this.py = new Float32Array(ST_POOL);
+ this.ox = new Float32Array(ST_POOL);
+ this.oy = new Float32Array(ST_POOL);
+ this.vx = new Float32Array(ST_POOL);
+ this.vy = new Float32Array(ST_POOL);
+ this.band = new Uint8Array(ST_POOL);
+ this.alive = new Uint8Array(ST_POOL);
+ this.key = new Uint8Array(ST_POOL);
+ this.order = new Uint16Array(ST_POOL);
+ this.head = 0;
+ this.nb = 0;
+ this.cols = [];
+ this.trail = null;
+ this.tctx = null;
+ }
+ resize() { this.trail = null; }
+ _bands(nb) {
+ this.nb = nb;
+ this.pan = new Float32Array(nb);
+ this.spread = new Float32Array(nb);
+ this.acc = new Float32Array(nb);
+ this.counts = new Int32Array(nb * 2);
+ this.alive.fill(0);
+ this.sbKey = '';
+ }
+ _emit(k, pan, ang, h) {
+ const i = this.head;
+ this.head = (i + 1) % ST_POOL;
+ const speed = Math.sqrt(2 * ST_GRAVITY * h);
+ this.px[i] = pan * 0.05 + (this.rand() - 0.5) * 0.02;
+ this.py[i] = 0;
+ this.ox[i] = this.px[i];
+ this.oy[i] = this.py[i];
+ this.vx[i] = Math.sin(ang) * speed;
+ this.vy[i] = Math.cos(ang) * speed;
+ this.band[i] = k;
+ this.alive[i] = 1;
+ }
+ draw(audio, cfg, t, dt) {
+ const ctx = this.ctx;
+ const W = this.canvas.width;
+ const H = this.canvas.height;
+ const v = cfg.visualizer;
+ const step = Math.min(0.05, dt || 0.016);
+ const sens = v.sensitivity || 1;
+ const nb = clamp(Math.round((v.barCount | 0) / 16), 4, 10);
+ if (this.nb !== nb) this._bands(nb);
+ if (!this.trail || this.trail.width !== W || this.trail.height !== H) {
+ this.trail = document.createElement('canvas');
+ this.trail.width = W;
+ this.trail.height = H;
+ this.tctx = this.trail.getContext('2d');
+ }
+
+ // Bant başına konum ve dağınıklık
+ const sb = this.sb;
+ if (sb) {
+ const sr = audio.sampleRate || 48000;
+ const scale = (v.spectrum && v.spectrum.scale) || 'log';
+ const key = nb + ':' + v.minFreq + ':' + v.maxFreq + ':' + scale + ':' + sr;
+ if (key !== this.sbKey) {
+ this.sbKey = key;
+ const S = window.SVSpectrum;
+ sb.configure(nb, v.minFreq, v.maxFreq, sr,
+ S ? S.bandEdges(nb, v.minFreq, Math.min(v.maxFreq, sr / 2), scale) : null);
+ }
+ sb.update(audio.timeL || audio.timeBytes, audio.timeR || audio.timeBytes, 128);
+ }
+ const follow = 1 - Math.exp(-step / 0.12);
+ const bars = audio.getBars(nb, v.minFreq, v.maxFreq, v.spectrum);
+ const power = 0.6 + 0.9 * clamp(v.thickness == null ? 0.42 : v.thickness, 0.1, 1);
+ // 1 bugünkü tepeyi verir (tavan 0.88 ekran). Üstü aynı yayı ekranın dışına taşır.
+ const reach = clamp(v.trailHeight == null ? 1 : v.trailHeight, 0.25, 15);
+ const kick = this.onset.push((audio.bass || 0) * sens, step);
+ for (let k = 0; k < nb; k++) {
+ const f = k / (nb - 1);
+ this.pan[k] += ((sb ? sb.pan[k] : 0) - this.pan[k]) * follow;
+ this.spread[k] += ((sb ? sb.spread[k] : 0) - this.spread[k]) * follow;
+ const e = clamp(bars[k] * sens, 0, 1);
+ this.acc[k] += 160 * e * Math.sqrt(e) * step;
+ const p = this.pan[k];
+ const tilt = (p < 0 ? -1 : 1) * Math.pow(Math.abs(p), ST_CURVE) * ST_TILT;
+ // Vuruşta bas bantları bir avuç fazladan atar
+ let burst = k < 2 && kick > 0 ? Math.round(5 + 9 * kick) : 0;
+ while (this.acc[k] >= 1 || burst > 0) {
+ if (burst > 0) burst--;
+ else this.acc[k] -= 1;
+ const ang = tilt + (this.rand() - 0.5) * (0.14 + this.spread[k] * ST_SCATTER);
+ const h = (0.25 + 0.55 * f) * power * (0.55 + 0.45 * e) * (0.85 + 0.3 * this.rand()) * reach;
+ this._emit(k, p, ang, Math.min(0.88 * reach, h));
+ }
+ }
+
+ // Fizik her karede. Tam ekran iz + parlama GPU'da kayda göre yavaş:
+ // kilitsiz ölçümde saniyede yüzlerce kez boyamak kuyruk bırakıyor ve
+ // bu kuyruk SONRAKİ sahnenin ilk saniyelerine yazılıyordu. 120 Hz
+ // boyama yeter; 60 ve 75 Hz'de her kare yine boyanır.
+ const paint = this._paintT == null || t - this._paintT >= 1 / 120;
+ const halfW = W / H / 2 + 0.05;
+ for (let i = 0; i < ST_POOL; i++) {
+ if (!this.alive[i]) continue;
+ this.vy[i] -= ST_GRAVITY * step;
+ this.px[i] += this.vx[i] * step;
+ this.py[i] += this.vy[i] * step;
+ if (this.py[i] < 0 || this.px[i] < -halfW || this.px[i] > halfW) this.alive[i] = 0;
+ }
+ if (!paint) return;
+ this._paintT = t;
+
+ // Kovalara sayma
+ const counts = this.counts;
+ counts.fill(0);
+ for (let i = 0; i < ST_POOL; i++) {
+ if (!this.alive[i]) continue;
+ const key = this.band[i] * 2 + (this.vy[i] < 0 ? 1 : 0);
+ this.key[i] = key;
+ counts[key]++;
+ }
+ // Sayma sıralaması: counts önce başlangıç, yerleştirmeden sonra bitiş
+ let sum = 0;
+ for (let q = 0; q < counts.length; q++) {
+ const c = counts[q];
+ counts[q] = sum;
+ sum += c;
+ }
+ for (let i = 0; i < ST_POOL; i++) {
+ if (this.alive[i]) this.order[counts[this.key[i]]++] = i;
+ }
+
+ // Çizim: iz tamponu saydama doğru söner, segmentler üstüne eklenir
+ const tc = this.tctx;
+ G.fadeTrail(tc, W, H, 0.05, this);
+ tc.globalCompositeOperation = 'source-over';
+ tc.lineCap = 'butt';
+ toneTable(v, cfg, t, nb, this.cols);
+ const cx = W / 2;
+ const floor = H;
+ const lw = Math.max(1, (v.lineWidth || 3) * 0.8 * (Math.min(W, H) / 1080));
+ let start = 0;
+ for (let q = 0; q < counts.length; q++) {
+ const end = counts[q];
+ if (end > start) {
+ const k = q >> 1;
+ tc.strokeStyle = rgba(this.cols[k], (q & 1) ? 0.45 : 0.9);
+ tc.lineWidth = lw * (2.4 - 1.6 * (k / (nb - 1)));
+ tc.beginPath();
+ for (let j = start; j < end; j++) {
+ const i = this.order[j];
+ tc.moveTo(cx + this.ox[i] * H, floor - this.oy[i] * H);
+ tc.lineTo(cx + this.px[i] * H, floor - this.py[i] * H);
+ this.ox[i] = this.px[i];
+ this.oy[i] = this.py[i];
+ }
+ tc.stroke();
+ }
+ start = end;
+ }
+ ctx.clearRect(0, 0, W, H);
+ ctx.drawImage(this.trail, 0, 0);
+ this.glow.apply(this.canvas, v.glow, 0.7);
+ }
+ dispose() {
+ this.trail = null;
+ this.tctx = null;
+ this.nb = 0;
+ }
+ }
+
window.SVModes = window.SVModes || {};
Object.assign(window.SVModes, {
ridges: Ridges,
@@ -980,5 +1196,6 @@
beatpads: BeatPads,
levelmeter: LevelMeter,
bounce: Bounce,
+ stereotrails: StereoTrails,
});
})();
diff --git a/src/visualizer/visualizer.js b/src/visualizer/visualizer.js
index 0ad989ff..87b82ea6 100644
--- a/src/visualizer/visualizer.js
+++ b/src/visualizer/visualizer.js
@@ -186,6 +186,70 @@
let frameAcc = 0; // kare hızı sınırı için birikim sayacı
let dpr = window.devicePixelRatio || 1;
let meterT = 0;
+ /* Davul vuruşu ölçer iletisine binmez (#437). Yerel yakalama karesi
+ vuruşu ana süreçte gider. Bu yol dosya çalma içindir: yakalama
+ karesi taze ise aynı vuruş ikinci kez gitmesin. */
+ let hitSent = { kick: 0, snare: 0, hat: 0 };
+
+ function oscHit(hits) {
+ if (!cfg.oscOut || cfg.oscOut.enabled !== true || cfg.oscOut.hits === false) return;
+ if (!window.api || !window.api.sendOscHit || !hits) return;
+ if (audio.lastFrameTs && performance.now() - audio.lastFrameTs < 250) return;
+ const msg = { kick: 0, snare: 0, hat: 0 };
+ let changed = false;
+ for (const k of ['kick', 'snare', 'hat']) {
+ const v = hits[k] > 0 ? hits[k] : 0;
+ msg[k] = v;
+ if ((v > 0 || hitSent[k] > 0) && v !== hitSent[k]) changed = true;
+ }
+ if (!changed) return;
+ hitSent = msg;
+ window.api.sendOscHit(msg);
+ }
+
+ function oscAnalysis(audio) {
+ if (!cfg.oscOut || cfg.oscOut.enabled !== true || cfg.oscOut.analysis === false) return null;
+ const a = audio.analysis;
+ if (!a) return null;
+ return {
+ centroid: a.centroid, rolloff: a.rolloff, flatness: a.flatness, crest: a.crest,
+ flux: a.flux, spread: a.spread, loudness: a.loudness, peak: a.peak,
+ dynamics: a.dynamics, harmonic: a.harmonic, percussive: a.percussive,
+ width: a.width, correlation: a.correlation,
+ pitchHz: a.pitch && a.pitch.hz,
+ pitchNote: a.pitch && a.pitch.note,
+ pitchConfidence: a.pitch && a.pitch.confidence,
+ key: a.key && a.key.name,
+ keyConfidence: a.key && a.key.confidence,
+ chord: a.chord && a.chord.name,
+ chordConfidence: a.chord && a.chord.confidence,
+ };
+ }
+
+ /* 16 logaritmik bant, görsel bar motorunun balistiği olmadan. Masa
+ sesi görür, çizimin yumuşatmasını değil. */
+ function oscSpectrum(audio) {
+ if (!cfg.oscOut || cfg.oscOut.enabled !== true || cfg.oscOut.analysis === false) return null;
+ const spec = audio.rawSpectrum ? audio.rawSpectrum() : null;
+ if (!spec || !spec.length || !audio.binHz) return null;
+ const n = 16;
+ const out = new Array(n);
+ const nyq = (audio.sampleRate || 48000) / 2;
+ const log0 = Math.log(30);
+ const log1 = Math.log(Math.min(16000, nyq));
+ for (let i = 0; i < n; i++) {
+ const f0 = Math.exp(log0 + (log1 - log0) * (i / n));
+ const f1 = Math.exp(log0 + (log1 - log0) * ((i + 1) / n));
+ let i0 = Math.max(0, Math.floor(f0 / audio.binHz));
+ let i1 = Math.min(spec.length - 1, Math.ceil(f1 / audio.binHz));
+ if (i1 < i0) i1 = i0;
+ let s = 0;
+ let c = 0;
+ for (let k = i0; k <= i1; k++) { s += spec[k]; c++; }
+ out[i] = c ? Math.min(1, s / c) : 0;
+ }
+ return out;
+ }
// --------------------------------------------------------------------------
// Boyutlandırma
@@ -425,6 +489,8 @@
const t = now / 1000;
audio.update(dt);
+ const hits = audio.analysis && audio.analysis.hits;
+ if (hits) oscHit(hits);
/* Sessizlikte duraklat (güç tasarrufu).
@@ -517,6 +583,8 @@
yazmıyor; panel ekranda ne olduğunu, önizleme ve diğer ekranlar
da neyi izleyeceğini buradan öğreniyor. */
mdPreset,
+ analysis: oscAnalysis(audio),
+ spectrum: oscSpectrum(audio),
});
}
}
diff --git a/src/web/overlay.html b/src/web/overlay.html
index c401a2be..7abcc901 100644
--- a/src/web/overlay.html
+++ b/src/web/overlay.html
@@ -112,6 +112,7 @@
+
diff --git a/tests/drum-hits.test.js b/tests/drum-hits.test.js
new file mode 100644
index 00000000..ab37cd3b
--- /dev/null
+++ b/tests/drum-hits.test.js
@@ -0,0 +1,51 @@
+'use strict';
+/* Yakalama karesindeki davul vuruşu. Çizim karesine bağlı değil. */
+
+const test = require('node:test');
+const assert = require('node:assert');
+const dgram = require('dgram');
+const { DrumHits } = require('../src/main/drum-hits');
+const osc = require('../src/main/osc-out');
+
+function kickFrame() {
+ const freq = new Uint8Array(1024);
+ for (let i = 1; i <= 6; i++) freq[i] = 255;
+ return freq;
+}
+
+test('sessiz kareden sonra bas vuruşu ve kapanış 0', () => {
+ const d = new DrumHits();
+ const quiet = new Uint8Array(1024);
+ assert.strictEqual(d.push(quiet, 48000, 1000), null);
+ const hit = d.push(kickFrame(), 48000, 1014);
+ assert.ok(hit && hit.kick > 0, 'kick gelmedi');
+ assert.strictEqual(hit.snare, 0);
+ const close = d.push(kickFrame(), 48000, 1028);
+ assert.ok(close, 'kapanış yok');
+ assert.strictEqual(close.kick, 0);
+});
+
+test('yakalama vuruşu UDP ile /hit/kick olarak çıkar', async () => {
+ const sock = dgram.createSocket('udp4');
+ const got = [];
+ await new Promise((resolve) => sock.bind(0, '127.0.0.1', resolve));
+ const port = sock.address().port;
+ sock.on('message', (buf) => got.push(buf));
+ const d = new DrumHits();
+ const cfg = { enabled: true, host: '127.0.0.1', port, hits: true };
+ try {
+ await osc.start(cfg, { enabled: false, port: 1 });
+ d.push(new Uint8Array(1024), 48000, 2000);
+ const hit = d.push(kickFrame(), 48000, 2014);
+ assert.ok(hit && hit.kick > 0);
+ assert.ok(osc.hit(cfg, hit) > 0);
+ const deadline = Date.now() + 1000;
+ while (!got.length && Date.now() < deadline) await new Promise((r) => setTimeout(r, 20));
+ assert.ok(got.length > 0, 'paket gelmedi');
+ const raw = Buffer.concat(got);
+ assert.ok(raw.includes(Buffer.from('/cayadev/hit/kick\0')), 'adres pakette yok');
+ } finally {
+ await osc.stop();
+ sock.close();
+ }
+});
diff --git a/tests/osc-out.test.js b/tests/osc-out.test.js
new file mode 100644
index 00000000..f38aa0f0
--- /dev/null
+++ b/tests/osc-out.test.js
@@ -0,0 +1,473 @@
+'use strict';
+/* OSC çıkışı (#437): src/main/osc-out.js.
+ *
+ * Kodlama OSC 1.0 belirtimindeki iki örnek pakete bayt bayt karşılaştırılıyor;
+ * üretilen her paket uygulamanın kendi OSC alıcısının ayrıştırıcısıyla
+ * (osc-server.js) geri çözülüyor. Gönderim gerçek bir UDP soketine, bu
+ * makinenin döngü arayüzü üzerinden sınanıyor.
+ */
+const test = require('node:test');
+const assert = require('node:assert');
+const dgram = require('dgram');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+const O = require('../src/main/osc-out.js');
+const { parsePacket } = require('../src/main/osc-server.js');
+
+const root = path.join(__dirname, '..');
+const read = (rel) => fs.readFileSync(path.join(root, rel), 'utf8');
+const hex = (b) => Buffer.from(b).toString('hex');
+const decode = (buf) => { const out = []; parsePacket(buf, out, 0); return out[0]; };
+const on = (extra) => O.normalize(Object.assign({ enabled: true }, extra));
+const msgs = (items) => {
+ const out = [];
+ for (const it of items || []) {
+ if (it && it.bundle) out.push(...it.messages);
+ else out.push(it);
+ }
+ return out;
+};
+
+// ------------------------------------------------------------------ kodlama
+
+test('OSC 1.0 belirtimindeki iki örnek paket bayt bayt aynı', () => {
+ assert.strictEqual(
+ hex(O.encodeMessage('/oscillator/4/frequency', [['f', 440]])),
+ '2f6f7363696c6c61746f722f342f6672657175656e6379002c66000043dc0000'
+ );
+ assert.strictEqual(
+ hex(O.encodeMessage('/foo', [['i', 1000], ['i', -1], ['s', 'hello'], ['f', 1.234], ['f', 5.678]])),
+ '2f666f6f000000002c69697366660000000003e8ffffffff68656c6c6f0000003f9df3b640b5b22d'
+ );
+});
+
+test('dize NUL ile biter ve 4 bayta tamamlanır; UTF-8 karakter yarıda kesilmez', () => {
+ for (let n = 0; n <= 9; n++) {
+ const b = O.oscString('x'.repeat(n));
+ assert.strictEqual(b.length % 4, 0, 'boy ' + n);
+ assert.ok(b.length >= n + 1 && b.length - n <= 4, 'dolgu ' + n);
+ assert.strictEqual(b[b.length - 1], 0);
+ }
+ assert.strictEqual(O.oscString('a\0b').toString('utf8').replace(/\0+$/, ''), 'ab', 'içteki NUL atılmalı');
+ const long = O.oscString('ğ'.repeat(150)); // 300 bayt
+ const text = long.toString('utf8').replace(/\0+$/, '');
+ assert.ok(Buffer.byteLength(text) <= 200 && text.length === 100, 'kesme: ' + text.length);
+ assert.ok(!text.includes('�'), 'yarım karakter kalmış');
+});
+
+test('sonlu olmayan sayı 0, tam sayı int32 sınırında', () => {
+ const m = decode(O.encodeMessage('/x', [['f', NaN], ['f', Infinity], ['i', 1e12], ['i', -1e12], ['i', 2.6]]));
+ assert.deepStrictEqual(m.args, [0, 0, 2147483647, -2147483648, 3]);
+});
+
+// ------------------------------------------------------------------ ayarlar
+
+test('ayarlar: geçersiz her alan güvenli varsayılana düşer', () => {
+ assert.deepStrictEqual(O.normalize(undefined), Object.assign({}, O.DEFAULTS));
+ for (const host of ['evil host', 'a/b', '', 5, '-x.com', 'a'.repeat(254), '::1%eth0']) {
+ assert.strictEqual(on({ host }).host, '127.0.0.1', 'adres ' + host);
+ }
+ for (const host of ['192.168.1.20', 'resolume-pc.local', 'localhost', '::1', '[::1]', '2001:db8::20']) {
+ assert.strictEqual(on({ host }).host, host.replace(/^\[|\]$/g, ''), 'adres ' + host);
+ }
+ assert.strictEqual(on({ latencyMs: 80 }).latencyMs, 80);
+ assert.strictEqual(on({ latencyMs: 9000 }).latencyMs, 2000);
+ assert.strictEqual(on({ latencyMs: 'x' }).latencyMs, 0);
+ assert.deepStrictEqual(O.targetsOf(on({ extra: '10.0.0.8:9001\n[::1]:9002\nbad\n10.0.0.8:9001' })).map((t) => t.host + ':' + t.port),
+ ['127.0.0.1:9001', '10.0.0.8:9001', '::1:9002']);
+ for (const port of [0, 70000, 'x', 1.5, -1]) assert.strictEqual(on({ port }).port, 9001, 'port ' + port);
+ assert.strictEqual(on({ port: 7000 }).port, 7000);
+ assert.strictEqual(on({ rate: 0 }).rate, 1);
+ assert.strictEqual(on({ rate: 100 }).rate, 30);
+ assert.strictEqual(on({ rate: 'x' }).rate, 30);
+ assert.strictEqual(on({ prefix: '/cayadev/' }).prefix, '/cayadev');
+ assert.strictEqual(on({ prefix: '' }).prefix, '');
+ for (const prefix of ['/a/b/c/d/e', '/bad prefix', 'noslash', '/a//b']) {
+ assert.strictEqual(on({ prefix }).prefix, '/cayadev', 'önek ' + prefix);
+ }
+ assert.strictEqual(O.normalize({ enabled: 'yes' }).enabled, false, 'yalnız true açar');
+});
+
+test('varsayılan: kapalı, hedef bu bilgisayar, OSC girişinin portundan farklı', () => {
+ global.window = global.window || {};
+ require('../src/shared/defaults.js');
+ const d = global.window.SV.defaultConfig();
+ assert.strictEqual(d.oscOut.enabled, false);
+ assert.strictEqual(d.oscOut.host, '127.0.0.1');
+ assert.notStrictEqual(d.oscOut.port, d.control.osc.port, 'iki varsayılan geri besleme olurdu');
+ assert.deepStrictEqual(O.normalize(d.oscOut), Object.assign({}, O.DEFAULTS), 'varsayılanlar iki yerde aynı');
+});
+
+// --------------------------------------------------------------------- plan
+
+const FRAME = { level: 0.5, bass: 1.7, mid: -0.2, treble: NaN };
+
+test('seviyeler ayarlanan hızda, 0..1 aralığında', () => {
+ const p = new O.Planner();
+ const o = on({ rate: 10, hits: false, tempo: false, state: false });
+ const at = [0, 50, 98, 120, 199, 230].filter((t) => p.frame(o, FRAME, {}, t).length);
+ assert.deepStrictEqual(at, [0, 120, 230]);
+ const raw = new O.Planner().frame(o, FRAME, {}, 0);
+ assert.strictEqual(raw.length, 1);
+ assert.strictEqual(raw[0].bundle, true, 'dört bant tek bundle');
+ const m = msgs(raw);
+ assert.deepStrictEqual(m.map((x) => [x[0], x[1][0][1]]), [
+ ['/cayadev/level', 0.5], ['/cayadev/bass', 1], ['/cayadev/mid', 0], ['/cayadev/treble', 0],
+ ]);
+});
+
+/* Uygulamada ölçüldü: ölçer iletileri ~33 ms arayla ama titreyerek
+ geliyor. Eski aralık eşiği 30 Hz ayarında 17 Hz gönderiyordu. */
+test('seviye hızı ölçer iletileri titrese de ortalamada tutuyor', () => {
+ let seed = 7;
+ const rand = () => { seed = (seed * 1103515245 + 12345) & 0x7fffffff; return seed / 0x7fffffff; };
+ for (const rate of [30, 20, 15, 10, 1]) {
+ const p = new O.Planner();
+ const o = on({ rate, hits: false, tempo: false, state: false });
+ let sent = 0;
+ for (let i = 0, t = 0; t < 10000; i++, t = i * 33.3 + (rand() - 0.5) * 8) {
+ if (p.frame(o, FRAME, {}, t).length) sent++;
+ }
+ const want = Math.min(rate, 30) * 10;
+ assert.ok(Math.abs(sent - want) <= Math.max(2, want * 0.03), rate + ' Hz: 10 sn\'de ' + sent + ', beklenen ~' + want);
+ }
+ // Ölçer durup geri gelince birikmiş ileti seli yok
+ const p = new O.Planner();
+ const o = on({ rate: 30, hits: false, tempo: false, state: false });
+ p.frame(o, FRAME, {}, 0);
+ const burst = [5000, 5010, 5020, 5030].filter((t) => p.frame(o, FRAME, {}, t).length).length;
+ assert.strictEqual(burst, 1, 'duraklamadan sonra tek ileti');
+});
+
+test('vuruşlar yalnız gerçekleştiğinde ve hız sınırına takılmadan', () => {
+ const p = new O.Planner();
+ const o = on({ levels: false, tempo: false, state: false });
+ assert.deepStrictEqual(p.frame(o, { hits: { kick: 0, snare: 0, hat: 0 } }, {}, 0), []);
+ const m = msgs(p.frame(o, { hits: { kick: 0.8, snare: 0, hat: 1.4 } }, {}, 1));
+ assert.deepStrictEqual(m, [['/cayadev/hit/kick', [['f', 0.8]]], ['/cayadev/hit/hat', [['f', 1]]]]);
+ const closed = msgs(p.frame(o, { hits: { kick: 0, snare: 0, hat: 0 } }, {}, 2));
+ assert.deepStrictEqual(closed, [['/cayadev/hit/kick', [['f', 0]]], ['/cayadev/hit/hat', [['f', 0]]]]);
+ assert.deepStrictEqual(p.frame(o, { hits: { kick: 0, snare: 0, hat: 0 } }, {}, 3), [], 'kapanış bir kez');
+ assert.strictEqual(p.frame(on({ hits: false, levels: false, tempo: false, state: false }), { hits: { kick: 1 } }, {}, 2).length, 0);
+});
+
+test('tempo: değişince ya da saniyede bir, güvenle birlikte', () => {
+ const p = new O.Planner();
+ const o = on({ levels: false, hits: false, state: false });
+ const sent = (bpm, t) => msgs(p.frame(o, {}, { bpm, confidence: 1.3 }, t)).map((m) => m[0] + '=' + m[1][0][1]);
+ assert.deepStrictEqual(sent(120, 0), ['/cayadev/tempo/bpm=120', '/cayadev/tempo/confidence=1']);
+ assert.deepStrictEqual(sent(120.3, 100), ['/cayadev/tempo/bpm=120.3', '/cayadev/tempo/confidence=1'], 'yarım BPM altı da hemen gider');
+ assert.strictEqual(sent(121, 200).length, 2);
+ assert.deepStrictEqual(sent(121, 900), []);
+ assert.strictEqual(sent(121, 1250).length, 2, 'saniyelik yineleme');
+ assert.deepStrictEqual(sent(0, 3000), [], 'tempo yokken sessiz');
+ assert.deepStrictEqual(sent(NaN, 3001), []);
+});
+
+test('durum: değişimde, beş saniyede bir yine; boşa dönüş bir kez', () => {
+ const p = new O.Planner();
+ const o = on({ levels: false, hits: false, tempo: false });
+ const ctx = { scene: 'Intro', visualizer: 'bars', background: 'gradient' };
+ const names = (frame, c, t) => msgs(p.frame(o, frame, c, t)).map((m) => m[0] + '=' + m[1][0][1]);
+ assert.deepStrictEqual(names({}, ctx, 0), [
+ '/cayadev/scene=Intro', '/cayadev/visualizer=bars', '/cayadev/background=gradient', '/cayadev/milkdrop/preset=',
+ ]);
+ assert.deepStrictEqual(names({}, ctx, 100), []);
+ assert.deepStrictEqual(names({}, Object.assign({}, ctx, { scene: 'Drop' }), 200), ['/cayadev/scene=Drop']);
+ assert.deepStrictEqual(names({ mdPreset: { name: 'Geiss - Reaction' } }, Object.assign({}, ctx, { scene: 'Drop' }), 300),
+ ['/cayadev/milkdrop/preset=Geiss - Reaction']);
+ assert.deepStrictEqual(names({ mdPreset: null }, Object.assign({}, ctx, { scene: 'Drop' }), 400), ['/cayadev/milkdrop/preset=']);
+ assert.deepStrictEqual(names({}, Object.assign({}, ctx, { scene: 'Drop' }), 5000),
+ ['/cayadev/scene=Drop', '/cayadev/visualizer=bars', '/cayadev/background=gradient', '/cayadev/milkdrop/preset='],
+ 'boş preset de yinelenir');
+});
+
+test('tempo vuruşu: ölçüdeki yer 1..N; geçersiz ya da kapalıysa hiçbir şey', () => {
+ const p = new O.Planner();
+ assert.deepStrictEqual(msgs(p.beat(on(), { beat: 3, beatsPerBar: 4 })), [['/cayadev/tempo/beat', [['i', 3], ['i', 4]]]]);
+ const down = msgs(p.beat(on(), { beat: 1 }));
+ assert.deepStrictEqual(down[0], ['/cayadev/tempo/beat', [['i', 1], ['i', 4]]]);
+ assert.deepStrictEqual(down[1], ['/cayadev/tempo/downbeat', [['f', 1]]]);
+ for (const info of [{ beat: 0 }, { beat: 5, beatsPerBar: 4 }, null, 'x', { beat: 'a' }]) {
+ assert.deepStrictEqual(p.beat(on(), info), [], JSON.stringify(info));
+ }
+ assert.deepStrictEqual(p.beat(on({ tempo: false }), { beat: 1 }), []);
+});
+
+test('önek her adrese uygulanıyor; boş önek kökten', () => {
+ const m = msgs(new O.Planner().frame(on({ prefix: '/vj/a', hits: false, tempo: false, state: false }), FRAME, {}, 0));
+ assert.ok(m.every((x) => x[0].startsWith('/vj/a/')));
+ const r = msgs(new O.Planner().frame(on({ prefix: '', hits: false, tempo: false, state: false }), FRAME, {}, 0));
+ assert.strictEqual(r[0][0], '/level');
+ assert.strictEqual(msgs(new O.Planner().beat(on({ prefix: '' }), { beat: 2 }))[0][0], '/tempo/beat');
+});
+
+test('üretilen her ileti uygulamanın kendi OSC alıcısıyla geri çözülüyor', () => {
+ const p = new O.Planner();
+ const o = on();
+ const planned = p.frame(o, Object.assign({ hits: { kick: 0.9, snare: 0.4, hat: 0.2 }, mdPreset: { name: 'Martin - Liquid' } }, FRAME),
+ { bpm: 127.5, confidence: 0.75, scene: 'Main', visualizer: 'stereotrails', background: 'nebula' }, 0)
+ .concat(p.beat(o, { beat: 2, beatsPerBar: 3 }));
+ const flat = msgs(planned);
+ assert.ok(flat.length >= 4 + 3 + 2 + 4 + 1);
+ for (const item of planned) {
+ if (!item.bundle) continue;
+ const inner = [];
+ parsePacket(O.encodeBundle(item.messages, item.time), inner, 0);
+ assert.strictEqual(inner.length, item.messages.length, 'bundle açılmalı');
+ }
+ for (const [address, args] of flat) {
+ const m = decode(O.encodeMessage(address, args));
+ assert.ok(m, 'çözülemedi: ' + address);
+ assert.strictEqual(m.address, address);
+ assert.strictEqual(m.args.length, args.length);
+ args.forEach(([t, v], i) => {
+ if (t === 'f') assert.ok(Math.abs(m.args[i] - v) < 1e-5, address + ' ' + m.args[i] + ' / ' + v);
+ else assert.strictEqual(m.args[i], v, address);
+ });
+ }
+});
+
+test('saat: faz, ölçü fazı, çalma, gecikme ve ölçü başının kapanışı', () => {
+ const p = new O.Planner();
+ const o = on({ levels: false, hits: false, state: false, latencyMs: 0 });
+ const at0 = msgs(p.frame(o, {}, { bpm: 120, confidence: 1, phase: 0.25, beat: 2, beatsPerBar: 4, playing: true }, 0));
+ const phase = at0.find((m) => m[0] === '/cayadev/tempo/beat/phase');
+ const bar = at0.find((m) => m[0] === '/cayadev/tempo/bar/phase');
+ assert.ok(Math.abs(phase[1][0][1] - 0.25) < 1e-6);
+ assert.ok(Math.abs(bar[1][0][1] - (1.25 / 4)) < 1e-6);
+ assert.ok(at0.some((m) => m[0] === '/cayadev/transport' && m[1][0][1] === 'playing'));
+ const late = on({ levels: false, hits: false, state: false, latencyMs: 250 });
+ const shifted = msgs(new O.Planner().frame(late, {}, { bpm: 120, phase: 0.25, beat: 1, beatsPerBar: 4 }, 0))
+ .find((m) => m[0] === '/cayadev/tempo/beat/phase');
+ assert.ok(Math.abs(shifted[1][0][1] - 0.75) < 1e-6, '250 ms, 120 BPM’de yarım vuruş geri');
+ const edge = new O.Planner();
+ edge.beat(o, { beat: 1, beatsPerBar: 4 }, 0);
+ const close = msgs(edge.frame(o, {}, { bpm: 120, phase: 0.05, beat: 1, beatsPerBar: 4 }, 50));
+ assert.ok(close.some((m) => m[0] === '/cayadev/tempo/downbeat' && m[1][0][1] === 0));
+ assert.strictEqual(msgs(edge.clock(o, { playing: false, bpm: 120, phase: 0.2, beat: 1, beatsPerBar: 4 }, 80))
+ .find((m) => m[0] === '/cayadev/transport')[1][0][1], 'stopped');
+});
+
+test('sessizlik, çözümleme, tayf, renk, gösteri, katman ve deste', () => {
+ const p = new O.Planner();
+ const o = on({ hits: false, tempo: false, analysis: true });
+ const quiet = (t, level) => msgs(p.frame(o, { level, bass: 0, mid: 0, treble: 0 }, { scene: 'A', visualizer: 'bars', background: 'solid' }, t))
+ .filter((m) => m[0] === '/cayadev/silence');
+ assert.deepStrictEqual(quiet(0, 0), []);
+ assert.deepStrictEqual(quiet(399, 0), []);
+ assert.deepStrictEqual(quiet(400, 0), [['/cayadev/silence', [['i', 1]]]]);
+ assert.deepStrictEqual(quiet(500, 0), []);
+ assert.deepStrictEqual(quiet(600, 0.2), [['/cayadev/silence', [['i', 0]]]]);
+ const rich = msgs(new O.Planner().frame(on({ hits: false, tempo: false, state: false }), Object.assign({}, FRAME, {
+ analysis: { centroid: 0.2, correlation: -0.4, pitchHz: 440, pitchNote: 'A4', key: 'Am', chord: 'C', chordConfidence: 0.8 },
+ spectrum: [0.25, 1.4],
+ }), {}, 0));
+ assert.strictEqual(rich.find((m) => m[0] === '/cayadev/analysis/centroid')[1][0][1], 0.2);
+ assert.ok(Math.abs(rich.find((m) => m[0] === '/cayadev/analysis/correlation')[1][0][1] + 0.4) < 1e-5);
+ assert.strictEqual(rich.find((m) => m[0] === '/cayadev/analysis/pitch')[1][0][1], 440);
+ assert.strictEqual(rich.find((m) => m[0] === '/cayadev/analysis/key')[1][0][1], 'Am');
+ assert.deepStrictEqual(rich.find((m) => m[0] === '/cayadev/spectrum')[1].map((a) => a[1]), [0.25, 1]);
+ const show = msgs(new O.Planner().frame(on({ levels: false, hits: false, tempo: false }), {
+ backgroundColors: ['#ffffff', '#000000'],
+ }, {
+ scene: 'A', visualizer: 'bars', background: 'solid',
+ show: {
+ blackout: true, palette: 'theme', brightness: 1.4, transition: 'cut', autovj: false, track: 'Ada — North',
+ timeline: false,
+ layers: [{ name: 'Ön', opacity: 0.5, enabled: true }, { name: 'Arka', opacity: 0, enabled: false }],
+ deck: { row: 2, col: 3, active: '2:3' },
+ opacity: 0.4,
+ crossfade: 0.25,
+ controls: [{ path: 'audio.sensitivity', value: 1.5 }],
+ },
+ }, 0));
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/background/color/1')[1][0][1], '#ffffff');
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/show/blackout')[1][0][1], 1);
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/show/brightness')[1][0][1], 1.4);
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/show/track')[1][0][1], 'Ada — North');
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/layer/count')[1][0][1], 2);
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/layer/1/opacity')[1][0][1], 0.5);
+ assert.deepStrictEqual(show.find((m) => m[0] === '/cayadev/deck/row')[1][0][1], 2);
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/deck/active')[1][0][1], '2:3');
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/show/opacity')[1][0][1], 0.4);
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/crossfade')[1][0][1], 0.25);
+ assert.strictEqual(show.find((m) => m[0] === '/cayadev/audio/sensitivity')[1][0][1], 1.5);
+});
+
+test('bundle zaman etiketi ana bilgisayar saatini taşır', () => {
+ const ms = Date.UTC(2026, 0, 1, 0, 0, 0);
+ const buf = O.encodeBundle([['/a', [['f', 1]]]], ms);
+ assert.strictEqual(buf.toString('ascii', 0, 7), '#bundle');
+ const sec = buf.readUInt32BE(8);
+ const frac = buf.readUInt32BE(12);
+ const unix = (sec - O.NTP_UNIX) * 1000 + Math.round(frac / 0x100000000 * 1000);
+ assert.ok(Math.abs(unix - ms) <= 1, unix);
+ const got = [];
+ parsePacket(buf, got, 0);
+ assert.strictEqual(got[0].address, '/a');
+ assert.ok(Math.abs(got[0].args[0] - 1) < 1e-6);
+});
+
+// ---------------------------------------------------------- geri besleme
+
+test('geri besleme: hedef bu bilgisayarın açık OSC girişiyse gönderilmez', () => {
+ const o = on({ port: 9000 });
+ assert.strictEqual(O.loopError(o, '127.0.0.1', { enabled: true, port: 9000 }), O.LOOP);
+ assert.strictEqual(O.loopError(o, '255.255.255.255', { enabled: true, port: 9000 }), O.LOOP, 'yayın da bu makineye döner');
+ assert.strictEqual(O.loopError(o, '127.0.0.1', { enabled: false, port: 9000 }), null, 'giriş kapalı');
+ assert.strictEqual(O.loopError(o, '127.0.0.1', { enabled: true, port: 9001 }), null, 'başka port');
+ assert.strictEqual(O.loopError(o, '203.0.113.5', { enabled: true, port: 9000 }), null, 'başka makine');
+ for (const a of ['127.0.0.1', '127.8.8.8', 'localhost', '0.0.0.0']) assert.ok(O.isLocalAddress(a), a);
+ assert.ok(!O.isLocalAddress('203.0.113.5'));
+ // Makinenin kendi IPv4 adresi (varsa) ve onun alt ağ yayın adresi
+ const own = [].concat(...Object.values(os.networkInterfaces())).find((a) => a && !a.internal && (a.family === 'IPv4' || a.family === 4));
+ if (own) {
+ assert.ok(O.isLocalAddress(own.address), own.address);
+ const ip = own.address.split('.').map(Number);
+ const mask = own.netmask.split('.').map(Number);
+ assert.ok(O.isLocalAddress(ip.map((x, i) => x | (~mask[i] & 255)).join('.')), 'alt ağ yayını');
+ }
+});
+
+// ------------------------------------------------------------ gerçek UDP
+
+function receiver() {
+ return new Promise((resolve) => {
+ const sock = dgram.createSocket('udp4');
+ const got = [];
+ sock.on('message', (buf) => parsePacket(buf, got, 0));
+ sock.bind(0, '127.0.0.1', () => resolve({ sock, got, port: sock.address().port }));
+ });
+}
+const waitFor = (fn, ms) => new Promise((resolve) => {
+ const t0 = Date.now();
+ const tick = () => (fn() || Date.now() - t0 > ms ? resolve(fn()) : setTimeout(tick, 10));
+ tick();
+});
+
+test('gerçek UDP: seviye, vuruş, tempo, durum ve tempo vuruşu alıcıya ulaşıyor', async () => {
+ const r = await receiver();
+ const cfg = { enabled: true, host: '127.0.0.1', port: r.port };
+ try {
+ const st = await O.start(cfg, { enabled: true, port: r.port + 1 });
+ assert.strictEqual(st.running, true, JSON.stringify(st));
+ assert.strictEqual(st.error, null);
+ const n = O.send(cfg, Object.assign({ hits: { kick: 1 } }, FRAME), { bpm: 128, confidence: 0.9, scene: 'Main', visualizer: 'bars', background: 'ink' });
+ assert.strictEqual(O.beat(cfg, { beat: 1, beatsPerBar: 4 }), 1);
+ await waitFor(() => r.got.length >= n + 1, 2000);
+ const addrs = r.got.map((m) => m.address);
+ for (const a of ['/cayadev/level', '/cayadev/hit/kick', '/cayadev/tempo/bpm', '/cayadev/scene', '/cayadev/tempo/beat']) {
+ assert.ok(addrs.includes(a), a + ' gelmedi: ' + addrs.join(', '));
+ }
+ assert.deepStrictEqual(r.got.find((m) => m.address === '/cayadev/tempo/beat').args, [1, 4]);
+ assert.strictEqual(O.status().packets, n + 1);
+ } finally {
+ await O.stop();
+ r.sock.close();
+ }
+ assert.strictEqual(O.status().running, false);
+ assert.strictEqual(O.send(cfg, FRAME, {}), 0, 'kapalıyken gönderim yok');
+});
+
+test('gerçek UDP: ikinci hedef ve IPv6 döngüsü de paketi alır', async () => {
+ const a = await receiver();
+ const b = await receiver();
+ const cfg = { enabled: true, host: '127.0.0.1', port: a.port, extra: '127.0.0.1:' + b.port, hits: false, tempo: false, state: false, analysis: false };
+ try {
+ const st = await O.start(cfg, { enabled: false, port: 1 });
+ assert.strictEqual(st.targets, 2, JSON.stringify(st));
+ assert.ok(O.send(cfg, FRAME, {}) > 0);
+ await waitFor(() => a.got.length > 0 && b.got.length > 0, 2000);
+ assert.ok(a.got.some((m) => m.address === '/cayadev/level'));
+ assert.ok(b.got.some((m) => m.address === '/cayadev/level'));
+ } finally {
+ await O.stop();
+ a.sock.close();
+ b.sock.close();
+ }
+});
+
+test('gerçek UDP: pozitif gecikme paketi bekletir', async () => {
+ const r = await receiver();
+ const cfg = { enabled: true, host: '127.0.0.1', port: r.port, latencyMs: 120, hits: false, tempo: false, state: false, analysis: false };
+ try {
+ await O.start(cfg, { enabled: false, port: 1 });
+ O.send(cfg, FRAME, {});
+ await new Promise((res) => setTimeout(res, 40));
+ assert.strictEqual(r.got.length, 0, 'gecikme dolmadan paket yok');
+ await waitFor(() => r.got.length > 0, 2000);
+ assert.ok(r.got.length > 0);
+ } finally {
+ await O.stop();
+ r.sock.close();
+ }
+});
+
+test('gerçek UDP: ::1 hedefine IPv6 paketi gider', async () => {
+ const sock = dgram.createSocket('udp6');
+ const got = [];
+ sock.on('message', (buf) => parsePacket(buf, got, 0));
+ await new Promise((resolve, reject) => sock.bind(0, '::1', () => resolve()).on('error', reject));
+ const port = sock.address().port;
+ const cfg = { enabled: true, host: '::1', port, hits: false, tempo: false, state: false, analysis: false };
+ try {
+ const st = await O.start(cfg, { enabled: true, port: port + 1 });
+ assert.strictEqual(st.running, true, JSON.stringify(st));
+ assert.strictEqual(st.error, null);
+ assert.ok(O.isLocalAddress('::1'));
+ O.send(cfg, FRAME, {});
+ await waitFor(() => got.length > 0, 2000);
+ assert.ok(got.some((m) => m.address === '/cayadev/level'), got.map((m) => m.address).join(','));
+ } finally {
+ await O.stop();
+ sock.close();
+ }
+});
+
+test('gerçek UDP: hedef açık OSC girişiyse paket gitmiyor, giriş kapanınca gidiyor', async () => {
+ const r = await receiver();
+ const cfg = { enabled: true, host: '127.0.0.1', port: r.port };
+ try {
+ const st = await O.start(cfg, { enabled: true, port: r.port });
+ assert.strictEqual(st.error, O.LOOP);
+ assert.strictEqual(O.send(cfg, FRAME, {}), 0);
+ assert.strictEqual(O.beat(cfg, { beat: 1 }), 0);
+ await new Promise((res) => setTimeout(res, 100));
+ assert.strictEqual(r.got.length, 0);
+ // Aynı hedefle yeniden eşitleme: soket kalır, denetim tazelenir
+ const again = await O.start(cfg, { enabled: false, port: r.port });
+ assert.strictEqual(again.error, null);
+ assert.ok(O.send(cfg, FRAME, {}) > 0);
+ await waitFor(() => r.got.length > 0, 2000);
+ assert.ok(r.got.length > 0);
+ } finally {
+ await O.stop();
+ r.sock.close();
+ }
+});
+
+// --------------------------------------------------------------- bağlantı
+
+test('bağlantı: ana süreç, panel ve görselleştirici çıkışı doğru yerden besliyor', () => {
+ const main = read('src/main/main.js');
+ assert.match(main, /oscOut\.send\(currentConfig\.oscOut, data, oscOutContext\(\)\)/, 'ölçer iletisinden gönderim');
+ assert.match(main, /if \(!o\.enabled \|\| HW_OFF\) return oscOut\.stop\(\)/, 'otomasyonda ağa paket yok');
+ assert.match(main, /ipcMain\.on\('tempo:beat'[\s\S]{0,200}e\.sender !== adminWin\.webContents\) return;/, 'vuruş yalnız panelden');
+ assert.match(main, /oscOut\.stop\(\)\.catch/, 'kapanışta soket kapanıyor');
+ assert.match(read('src/visualizer/visualizer.js'), /window\.api\.sendOscHit\(msg\)/);
+ assert.match(main, /ipcMain\.on\('osc-hit'/);
+ assert.match(main, /nativeDrums\.push\(frame\.freq[\s\S]{0,700}sendToVisualizers\('native-audio'/);
+ assert.match(main, /ipcMain\.on\('tempo:clock'/);
+ assert.match(main, /oscOut\.clock\(currentConfig\.oscOut/);
+ assert.match(read('src/admin/autovj.js'), /reportTempoClock\(oscClockPayload/);
+ assert.match(read('src/admin/admin.js'), /SVShow\.blackout = !!blackoutSaved/);
+ assert.match(read('README.md'), /\/tempo\/beat\/phase/);
+ assert.match(read('README.tr.md'), /\/tempo\/beat\/phase/);
+ assert.match(read('src/admin/autovj.js'), /fired && cfg\.oscOut && cfg\.oscOut\.enabled[\s\S]{0,120}reportTempoBeat/);
+ const admin = read('src/admin/admin.js');
+ assert.match(admin, /id: 'oscOut'[\s\S]{0,400}roots: \['oscOut'\][\s\S]{0,120}surface: 'oscout'/);
+ assert.strictEqual(require('../src/shared/mcp.js').groupForPath('oscOut.host'), 'output', 'MCP izni Art-Net ile aynı');
+});
diff --git a/tests/stereo-bands.test.js b/tests/stereo-bands.test.js
new file mode 100644
index 00000000..2108ca31
--- /dev/null
+++ b/tests/stereo-bands.test.js
@@ -0,0 +1,296 @@
+'use strict';
+/* Bant bant stereo ölçüm (src/shared/stereo-bands.js) ve onu çizen
+ * Stereo İzler modu.
+ *
+ * Ölçüm bilinen cevaplı sinyallerle sınanıyor: tek kanaldaki bir ton
+ * kendi bandında tam yanda, iki kanalda aynı sinyal tam ortada ve dar,
+ * ters faz ve ilişkisiz gürültü dağınık. Mod gerçek kaynağıyla, sahte bir
+ * tuvalde koşuyor; çizdiği segmentlerin nereye düştüğü ölçülüyor.
+ */
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const path = require('path');
+const vm = require('vm');
+
+const SB = require('../src/shared/stereo-bands.js');
+const SP = require('../src/shared/spectrum.js');
+
+const root = path.join(__dirname, '..');
+const read = (rel) => fs.readFileSync(path.join(root, rel), 'utf8');
+
+const N = 2048;
+const SR = 48000;
+const sine = (f, g) => Float32Array.from({ length: N }, (_, i) => g * Math.sin((2 * Math.PI * f * i) / SR));
+const zeros = () => new Float32Array(N);
+function noise(seed) {
+ let s = seed >>> 0;
+ return Float32Array.from({ length: N }, () => {
+ s ^= s << 13; s >>>= 0; s ^= s >> 17; s ^= s << 5; s >>>= 0;
+ return (s / 4294967296) * 1.2 - 0.6;
+ });
+}
+const toBytes = (f) => Uint8Array.from(f, (x) => Math.max(0, Math.min(255, Math.round(128 + x * 128))));
+/* 30 Hz..15 kHz arası 40 ton. sin ile cos aynı genlik tayfını verir ama
+ ilişkisizdir: her bantta enerji iki kanalda eşit (konum ~0), korelasyon
+ ~0 (dağınık). Gürültüde bantların konumu da rastgele sapıyor ve
+ yelpazeyi açan şeyin saçılma mı eğim mi olduğu ayrılamıyordu. */
+const TONES = Array.from({ length: 40 }, (_, i) => 30 * Math.pow(500, i / 39));
+const tones = (fn) => Float32Array.from({ length: N }, (_, i) =>
+ TONES.reduce((s, f, j) => s + 0.033 * fn((2 * Math.PI * f * i) / SR + j * 2.39996), 0));
+
+function bands(n) {
+ const sb = new SB.StereoBands();
+ sb.configure(n || 8, 20, 20000, SR);
+ return sb;
+}
+const bandOf = (sb, hz) => {
+ for (let k = 0; k < sb.n; k++) if (hz >= sb.edges[k] && hz < sb.edges[k + 1]) return k;
+ return -1;
+};
+
+// ------------------------------------------------------------------ ölçüm
+
+test('yalnız soldaki ton kendi bandında tam solda, yalnız sağdaki tam sağda, ikisi de dar', () => {
+ const sb = bands(8);
+ sb.update(sine(100, 0.8), zeros(), 0);
+ const k = bandOf(sb, 100);
+ assert.ok(k >= 0);
+ assert.strictEqual(sb.pan[k], -1);
+ assert.strictEqual(sb.spread[k], 0, 'tek kanaldaki kaynak tek noktada');
+ sb.update(zeros(), sine(5000, 0.8), 0);
+ const j = bandOf(sb, 5000);
+ assert.strictEqual(sb.pan[j], 1);
+ assert.strictEqual(sb.spread[j], 0);
+});
+
+test('iki bant ayrı yerde: soldaki bas ve sağdaki tiz birbirini sürüklemiyor', () => {
+ const sb = bands(8);
+ sb.update(sine(100, 0.8), sine(5000, 0.8), 0);
+ assert.ok(sb.pan[bandOf(sb, 100)] < -0.95, 'bas bandı ' + sb.pan[bandOf(sb, 100)]);
+ assert.ok(sb.pan[bandOf(sb, 5000)] > 0.95, 'tiz bandı ' + sb.pan[bandOf(sb, 5000)]);
+});
+
+test('aynı sinyal iki kanalda: her bant tam ortada ve dar (mono)', () => {
+ const sb = bands(8);
+ const x = noise(11);
+ sb.update(x, x, 0);
+ for (let k = 0; k < sb.n; k++) {
+ assert.strictEqual(sb.pan[k], 0, 'bant ' + k);
+ assert.ok(sb.spread[k] < 1e-6, 'bant ' + k + ' dağınıklık ' + sb.spread[k]);
+ assert.ok(sb.level[k] > SB.QUIET_RMS, 'bant ' + k + ' sessiz sayıldı');
+ }
+});
+
+test('sabit güçlü kaydırma: konum sin(p·π/2), dağınıklık 0', () => {
+ const sb = bands(6);
+ for (const p of [-1, -0.5, 0, 0.5, 1]) {
+ const th = ((p + 1) * Math.PI) / 4;
+ sb.update(sine(1000, 0.5 * Math.cos(th)), sine(1000, 0.5 * Math.sin(th)), 0);
+ const k = bandOf(sb, 1000);
+ assert.ok(Math.abs(sb.pan[k] - Math.sin((p * Math.PI) / 2)) < 1e-3, 'p=' + p + ': ' + sb.pan[k]);
+ assert.ok(sb.spread[k] < 1e-3, 'p=' + p + ' dağınıklık ' + sb.spread[k]);
+ }
+});
+
+test('ters faz ve ilişkisiz gürültü dağınık; konum yine ortada', () => {
+ const sb = bands(8);
+ const x = noise(3);
+ sb.update(x, x.map((v) => -v), 0);
+ for (let k = 0; k < sb.n; k++) {
+ assert.strictEqual(sb.spread[k], 1, 'ters faz bant ' + k);
+ assert.ok(Math.abs(sb.pan[k]) < 1e-6, 'ters faz konum ' + sb.pan[k]);
+ }
+ sb.update(noise(5), noise(9), 0);
+ // En alt bant 25-60 Hz: 1536 örnekte birkaç periyot, ölçümü gürültülü
+ for (let k = 1; k < sb.n; k++) assert.ok(sb.spread[k] > 0.8, 'ilişkisiz bant ' + k + ': ' + sb.spread[k]);
+});
+
+test('sessizlik ve nicemleme gürültüsü: yön yok, NaN yok', () => {
+ const sb = bands(8);
+ sb.update(zeros(), zeros(), 0);
+ for (let k = 0; k < sb.n; k++) {
+ assert.strictEqual(sb.level[k], 0);
+ assert.strictEqual(sb.pan[k], 0);
+ assert.strictEqual(sb.spread[k], 0);
+ }
+ // Tek basamaklık titreşim yalnız solda: yön seçilmemeli
+ const lsb = new Uint8Array(N).map((_, i) => 128 + (i % 3 === 0 ? 1 : 0));
+ sb.update(lsb, new Uint8Array(N).fill(128), 128);
+ for (let k = 0; k < sb.n; k++) assert.strictEqual(sb.pan[k], 0, 'bant ' + k + ': ' + sb.pan[k]);
+ // Eksik ya da boyları farklı kanallar
+ sb.update(null, zeros(), 0);
+ sb.update(zeros(), new Float32Array(10), 0);
+ for (let k = 0; k < sb.n; k++) assert.ok(Number.isFinite(sb.pan[k]) && sb.level[k] === 0);
+});
+
+test('bayt girişi (128 merkezli) kayan noktalıyla aynı sonucu veriyor', () => {
+ const a = bands(8);
+ const b = bands(8);
+ const l = sine(300, 0.6);
+ const r = sine(300, 0.3);
+ a.update(l, r, 0);
+ b.update(toBytes(l), toBytes(r), 128);
+ for (let k = 0; k < 8; k++) {
+ if (a.level[k] < 0.02) continue;
+ assert.ok(Math.abs(a.pan[k] - b.pan[k]) < 0.02, 'bant ' + k + ': ' + a.pan[k] + ' / ' + b.pan[k]);
+ }
+});
+
+test('kenarlar: logaritmik, sınırlar içinde; tayfın mel kenarları da kabul ediliyor', () => {
+ const e = SB.bandEdges(8, 20, 20000, 44100);
+ assert.strictEqual(e[0], 25, 'alt kenar 25 Hz\'e çekiliyor');
+ assert.ok(e[8] <= 44100 * 0.45 + 1e-9, 'üst kenar Nyquist\'in %45\'i');
+ for (let i = 1; i < 8; i++) assert.ok(Math.abs(e[i] / e[i - 1] - e[i + 1] / e[i]) < 1e-9, 'oranlar eşit');
+
+ const mel = SP.bandEdges(10, 20, 20000, 'mel');
+ const sb = new SB.StereoBands();
+ sb.configure(10, 20, 20000, SR, mel);
+ assert.strictEqual(sb.n, 10);
+ for (let i = 1; i < 10; i++) assert.ok(Math.abs(sb.edges[i] - mel[i]) < 1e-9, 'iç kenar ' + i + ' korunmadı');
+ for (let i = 1; i <= 10; i++) assert.ok(sb.edges[i] >= sb.edges[i - 1] * 1.05 - 1e-9, 'bant ' + i + ' çöktü');
+ // Sınırın dışına düşen kenarlar çöküp sonsuz Q üretmiyor
+ const fit = SB.fitEdges(Float64Array.from([1, 2, 3, 30000, 40000]), SR);
+ for (let i = 1; i < fit.length; i++) assert.ok(fit[i] > fit[i - 1], 'kenar ' + i);
+});
+
+test('update kare başına dizi ayırmıyor: aynı dizilere yazıyor', () => {
+ const sb = bands(8);
+ const before = [sb.pan, sb.spread, sb.level];
+ sb.update(noise(1), noise(2), 0);
+ const scratch = sb._l;
+ sb.update(noise(3), noise(4), 0);
+ assert.deepStrictEqual([sb.pan, sb.spread, sb.level], before);
+ assert.strictEqual(sb._l, scratch);
+});
+
+// --------------------------------------------------------------- Stereo İzler
+
+/* Mod gerçek dosyalarıyla koşuyor; iz tamponunun bağlamı moveTo/lineTo
+ çiftlerini, o anki çizgi kalınlığıyla (bant başına farklı) kaydediyor. */
+function runTrails(left, right, opts) {
+ const o = opts || {};
+ let segs = [];
+ let lw = 0;
+ let from = null;
+ const trailCtx = new Proxy({}, {
+ get(target, k) {
+ if (k === 'moveTo') return (x, y) => { from = [x, y]; };
+ if (k === 'lineTo') return (x, y) => { segs.push({ x0: from[0], y0: from[1], x, y, lw }); };
+ if (k in target) return target[k];
+ return () => {};
+ },
+ set(target, k, v) { if (k === 'lineWidth') lw = v; target[k] = v; return true; },
+ });
+ const plain = new Proxy({}, { get: (t, k) => (k in t ? t[k] : () => {}), set: (t, k, v) => { t[k] = v; return true; } });
+ const win = { document: { createElement: () => ({ width: 0, height: 0, getContext: () => trailCtx }) } };
+ win.window = win;
+ win.SVGlow = class { apply() {} };
+ const ctx = vm.createContext(win);
+ for (const f of ['src/shared/onset.js', 'src/shared/spectrum.js', 'src/shared/stereo-bands.js',
+ 'src/visualizer/modes/generative.js', 'src/visualizer/modes/generative2.js']) {
+ vm.runInContext(read(f), ctx, { filename: path.basename(f) });
+ }
+ const W = 1280;
+ const H = 720;
+ const mode = new win.SVModes.stereotrails({ width: W, height: H, getContext: () => plain });
+ const L = toBytes(left);
+ const R = toBytes(right);
+ const level = o.level == null ? 0.6 : o.level;
+ const audio = {
+ timeL: L, timeR: R, timeBytes: L, sampleRate: SR, bass: 0,
+ getBars: (n) => (o.bars ? Float32Array.from(o.bars) : new Float32Array(n).fill(level)),
+ };
+ const cfg = { visualizer: { barCount: 128, minFreq: 20, maxFreq: 20000, sensitivity: 1, thickness: 0.42, lineWidth: 3, glow: 0, colorMode: 'rainbow', trailHeight: o.trailHeight } };
+ for (let f = 0; f < (o.frames || 90); f++) {
+ segs = [];
+ mode.draw(audio, cfg, f / 60, 1 / 60);
+ }
+ // Segmentin ucu, tabanın ortasına göre (H biriminde)
+ return { segs, cx: W / 2, H, dx: segs.map((s) => (s.x - W / 2) / H) };
+}
+const mean = (a) => a.reduce((s, v) => s + v, 0) / a.length;
+const p90 = (a) => a.map(Math.abs).sort((x, y) => x - y)[Math.floor(a.length * 0.9)];
+
+test('Stereo İzler: soldaki ses sola, sağdaki sağa eğiliyor; mono dik', () => {
+ const left = runTrails(noise(21), zeros());
+ const right = runTrails(zeros(), noise(21));
+ const mono = runTrails(noise(21), noise(21));
+ for (const r of [left, right, mono]) assert.ok(r.segs.length > 200, 'parçacık az: ' + r.segs.length);
+ assert.ok(left.dx.filter((d) => d < 0).length / left.dx.length > 0.95, 'solda olmayan segment çok');
+ assert.ok(right.dx.filter((d) => d > 0).length / right.dx.length > 0.95, 'sağda olmayan segment çok');
+ assert.ok(mean(left.dx) < -0.15 && mean(right.dx) > 0.15, mean(left.dx) + ' / ' + mean(right.dx));
+ assert.ok(Math.abs(mean(mono.dx)) < 0.03, 'mono ortadan kaymış: ' + mean(mono.dx));
+ assert.ok(p90(mono.dx) < p90(left.dx) * 0.6, 'mono dik bir sütun olmalı');
+});
+
+test('Stereo İzler: dağınık ses (ilişkisiz kanallar) monodan geniş bir yelpaze açıyor', () => {
+ const mono = runTrails(tones(Math.sin), tones(Math.sin));
+ const wide = runTrails(tones(Math.sin), tones(Math.cos));
+ assert.ok(Math.abs(mean(wide.dx)) < 0.05, 'dağınık ses ortada kalmalı: ' + mean(wide.dx));
+ // Ölçüldü: ~8 kat; saçılma dağınıklığı okumasa ~1,5 kat
+ assert.ok(p90(wide.dx) > p90(mono.dx) * 4, p90(wide.dx) + ' / ' + p90(mono.dx));
+});
+
+test('Stereo İzler: ince bir stereo görüntü de görünür eğiliyor', () => {
+ // p = 0,15 sabit güçlü kaydırma; müzikte bantların çoğu bu kadar ortada
+ const th = (1.15 * Math.PI) / 4;
+ const src = tones(Math.sin);
+ const subtle = runTrails(src.map((x) => x * Math.cos(th) * Math.SQRT2), src.map((x) => x * Math.sin(th) * Math.SQRT2));
+ const hard = runTrails(zeros(), src.map((x) => x * Math.SQRT2));
+ // Ölçüldü: eğriyle tam sağın ~%72'si, doğrusal eşlemede ~%41'i
+ assert.ok(mean(subtle.dx) > mean(hard.dx) * 0.55, mean(subtle.dx) + ' / ' + mean(hard.dx));
+});
+
+test('Stereo İzler: her bant kendi yerinde — soldaki bas sola, sağdaki tiz sağa', () => {
+ const r = runTrails(sine(100, 0.8), sine(5000, 0.8));
+ const widths = [...new Set(r.segs.map((s) => s.lw))].sort((a, b) => b - a);
+ assert.ok(widths.length >= 6, 'bant sayısı: ' + widths.length);
+ // Kalın çizgi bas, ince çizgi tiz. Bas yayları kısa ve çabuk düşüyor:
+ // tek karede bant başına ~20 parçacık, bu yüzden iki bant birlikte
+ const lows = widths.slice(0, 2);
+ const highs = widths.slice(-2);
+ const bass = r.segs.filter((s) => lows.includes(s.lw)).map((s) => s.x - r.cx);
+ const treble = r.segs.filter((s) => highs.includes(s.lw)).map((s) => s.x - r.cx);
+ assert.ok(bass.length > 20 && treble.length > 20, bass.length + ' / ' + treble.length);
+ assert.ok(mean(bass) < 0 && mean(treble) > 0, 'bas ' + mean(bass) + ', tiz ' + mean(treble));
+});
+
+test('Stereo İzler: yükseklik 1 bugünkü tepeyi korur, üstü ekranın dışına çıkar', () => {
+ const srcL = noise(61);
+ const srcR = noise(62);
+ const base = runTrails(srcL, srcR, { frames: 90 });
+ const same = runTrails(srcL, srcR, { trailHeight: 1, frames: 90 });
+ const high = runTrails(srcL, srcR, { trailHeight: 2.5, frames: 90 });
+ const peak = (r) => Math.min(...r.segs.map((s) => Math.min(s.y0, s.y)));
+ assert.deepStrictEqual(same.segs, base.segs, 'ayar yokken ve 1 iken kare aynı olmalı');
+ assert.ok(high.segs.length > 20 && base.segs.length > 20);
+ // Ekran y'si yukarı küçülür. 2.5 kat, 720p'de tepeyi en az bir ekran boyu yukarı taşır.
+ assert.ok(peak(high) < peak(base) - 720, peak(high) + ' / ' + peak(base));
+});
+
+test('Stereo İzler: seviye getBars\'tan geliyor (tayf ayarları işliyor), sessizlikte çizim yok', () => {
+ const quiet = runTrails(noise(41), noise(42), { level: 0 });
+ assert.strictEqual(quiet.segs.length, 0, 'bar 0 iken parçacık atıldı');
+ const only = runTrails(noise(41), noise(42), { bars: [0.8, 0, 0, 0, 0, 0, 0, 0] });
+ assert.ok(only.segs.length > 20);
+ assert.strictEqual(new Set(only.segs.map((s) => s.lw)).size, 1, 'yalnız ilk bant atmalı');
+});
+
+test('Stereo İzler: aynı ses aynı kareyi veriyor (dışa aktarım için belirlenimli)', () => {
+ const a = runTrails(noise(51), noise(52), { frames: 40 });
+ const b = runTrails(noise(51), noise(52), { frames: 40 });
+ assert.deepStrictEqual(a.segs, b.segs);
+ assert.doesNotMatch(read('src/visualizer/modes/generative2.js'), /Math\.random\(/);
+});
+
+/* Mod SVStereoBands'i kurulurken okuyor: yardımcı sayfada yoksa katman
+ sessizce boş çizer. Mod dosyasını yükleyen her sayfa yardımcıyı da
+ yüklemeli (bkz. mode-catalog.test.js, Çalan Parça). */
+test('Stereo İzler modunu yükleyen her sayfa stereo-bands.js\'i de yüklüyor', () => {
+ for (const page of ['src/visualizer/index.html', 'src/web/overlay.html', 'src/exporter/index.html', 'src/admin/index.html']) {
+ const html = read(page);
+ assert.ok(html.includes('modes/generative2.js'), page + ': mod yok');
+ assert.ok(html.includes('shared/stereo-bands.js'), page + ': SVStereoBands yok');
+ }
+});