A broadcast vezérlés fő összetevői: SuperCollider server az audio fájlok lejátszásra; Node.js java script a SuperCollider vezérlésére OSC (Open Sound Control) használatával. Ezek a háttérben futnak szolgáltatásként, és a megadott portokon lehet elérni a szolgáltatásokat.
A SuperCollider indításáról itt lehet olvasni bővebben.
SuperCollider: scplay3.1.scd
Az scplay rendszermag már a harmadik verzióban kerül továbbfejlesztésre. Több próbálkozás közül ez a verzió hozta meg a várt működést.
A fájl helye:
./mtm.project/systems/broadcast/core/scd/scplay3.x.scd
Indítása SuperCollider serveren
s.boot;
"/home/mtm/html/mtm.project/systems/broadcast/core/scd/scplay3.1.scd".load;
Ha az OSC parancsokat szeretnénk az sclang környezetében használni, akkor meg kell nyitni egy portot, melyen keresztül kommunikálni tudunk a SuperCollider serverrel
n = NetAddr("127.0.0.1", NetAddr.langPort);
Bufferelés
Az eredeti gondolat az volt, hogy 2 buffer kerül létrehozásra, melybe betöltető egy audio fájl (URL alapján) elindítható a lejátszás, dinamikus fade-out használatával meg lehet állítani a lejátszást.
Az scplay 3. verziója több szálat is képes bufferelni, és a bufferek mindegyikét külön-külön tudja kezelni (lejátszani és megállítani) a buffer nevével, melyet a fájl betöltésénél kell megadni (lásd: setfile).
A bufferek egy Dictionary típusú változóban kerülnek tárolására.
~buffers = Dictionary.new;
A SuperCollider kód Dokumentáció
Ez a SuperCollider szkript egy egyszerű OSC-vezérelt hanglejátszó rendszert valósít meg. A kód a SuperCollider szerveren fut, ahol az OSC (Open Sound Control) üzeneetek által kapott parancsokat hajtja végre. A szkript képes hanglefájlokat beolvasni, lejátszani, megállítani és figyelni a lejtátszási pozíciót.
1. Globális Változók
~buffers = Dictionary.new;
~players = Dictionary.new;
~buffers: Egy szótár („Dictionary”), amely a betöltött hangfájlokat Buffer objektumok formájában tárolja.~players: Egy szótár, amely a futó Synth objektumokat tárolja, amelyek a hangfájlokat lejátsszák.
2. OSC Definíciók
2.1. Hangfájl beállítása
OSCdef(\setFile, { |msg|
var bufferName;
~filePath = msg[1];
bufferName = msg[2];
"File set to: ".post; ~filePath.postln;
("Buffer: " + bufferName).postln;
~buffers[bufferName] = Buffer.read(s, ~filePath);
}, '/setFile');
OSCdef(\setFile, { |msg| ... }, '/setFile');: Egy OSC hallgató, amely a /setFile üzeneetre reagál.msg[1]: A beolvasandó hangfájl elérési útja.msg[2]: A buffer neve, amely alatt a fájl elérhető lesz.Buffer.read(s, ~filePath): A hangfájl betöltése a szerverre, majd a ~buffers szótárban elmentése.
2.2. Hangfájl leátszása
OSCdef(\play, { |msg|
var bufferName;
bufferName = msg[1];
if (~filePath.notNil) {
~players[bufferName] = Synth(\playerSynth, [\buf, ~buffers[bufferName]]);
"Playing file: ".post; ~filePath.postln;
("Playing buffer: " + bufferName).postln;
} {
"No file set!".postln;
};
}, '/play');
OSCdef(\play, { |msg| ... }, '/play');: Egy OSC hallgató, amely a /play üzenetre reagál.msg[1]: A buffer neve, amelyet le kell játszani.Synth(\playerSynth, [\buf, ~buffers[bufferName]]): Egy Synth példányt hoz létre, amely lejátssza a bufferName nevű bufferben lévő hangot.~players[bufferName]: A futó Synth példányt tárolja a megfelelő kulcs alatt.
2.3. Lejátszás leállítása
OSCdef(\stop, { |msg|
var fadeTime = msg[1].asFloat;
var bufferName = msg[2];
fadeTime = fadeTime.max(0.1);
if (~players[bufferName].notNil) {
"Stopping " + bufferName + "] with fade-out: ".post; fadeTime.postln;
~players[bufferName].set(\gate, 0, \fadeTime, fadeTime);
~players[bufferName] = nil;
} {
("No active player! [" + bufferName + "]").postln;
};
}, '/stop');
fadeTime = msg[1].asFloat: Az elhalvás ideje.fadeTime = fadeTime.max(0.1): Biztosítja, hogy ne legyen 0 vagy negatív.~players[bufferName].set(\gate, 0, \fadeTime, fadeTime): Az envelope gate lezárásával elindít egy fade-out-ot.~players[bufferName] = nil;: A referencia törlése.
3. Lejátszás definíciója (SynthDef)
SynthDef(\playerSynth, {
|buf, fadeTime = 1.0, gate = 1|
var sig, env, pos, rate;
rate = BufRateScale.kr(buf);
env = EnvGen.kr(Env.asr(0.01, 1, fadeTime, curve: -4), gate, doneAction: 2);
sig = PlayBuf.ar(2, buf, rate, loop: 0);
pos = Phasor.ar(0, rate, 0, BufFrames.kr(buf));
SendReply.kr(Impulse.kr(1), '/playbackPosition', pos / BufSampleRate.kr(buf));
Out.ar(0, sig * env);
}).add;
BufRateScale.kr(buf): A buffer sebességi arányának kiszámítása.EnvGen.kr(...): Az envelope generálása a fade-out kezelésére.PlayBuf.ar(...): A buffer lejátszása.Phasor.ar(...): A lejátszási pozíció kiszámítása.SendReply.kr(...): A lejtátszási időközön OSC üzenetet küld.Out.ar(0, sig * env): A jel kiküldése a hangkimenetre.
4. Lejátszási Pozíció Figyelése
OSCdef(\positionListener, { |msg|
var time, min, sec;
time = msg[3].asInteger;
min = time.div(60);
sec = time.mod(60);
("Playback Position: " ++ min.asString ++ ":" ++ sec.asString).postln;
}, '/playbackPosition');
Ez az OSC hallgató figyeli a /playbackPosition üzeneetet, és formázottan kiírja az aktuális időpozíciót.
Node.js OSC és WebSocket szerver dokumentáció
A fájl helye:
./mtm.project/systems/broadcast/core/osc/wss_osc.js
Áttekintés
Ez a Node.js alkalmazás egy Open Sound Control (OSC) protokollt használó szerver, amely kommunikál egy SuperCollider (SC) szerverrel. Az alkalmazás egy WebSocket szervert is futtat, amely lehetővé teszi, hogy a kliensek valós időben küldjenek parancsokat és kapjanak visszajelzéseket a lejátszási pozícióról.
Függőségek
Az alkalmazás két fő Node.js modult használ:
osc: Az OSC protokoll kezeléséhezws: WebSocket kommunikációhoz
A szükséges csomagok telepíthetők a következő paranccsal:
npm install osc ws
OSC Szerver Konfiguráció
const osc = require('osc');
Az osc modult importáljuk, hogy az OSC protokollal tudjunk kommunikálni.
const udpPort = new osc.UDPPort({
localAddress: "0.0.0.0",
localPort: 57121, // Az SC által figyelt port
remoteAddress: "127.0.0.1",
remotePort: 57122 // SC alapértelmezett OSC portja
});
Létrehozunk egy UDP alapú OSC kapcsolatot:
localAddress: "0.0.0.0": A szerver minden hálózati interfészen figyel.localPort: 57121: A helyi OSC szerver ezen a porton hallgat.remoteAddress: "127.0.0.1": A cél SC szerver azonosítója (localhost).remotePort: 57122: Az SC alapértelmezett OSC portja.
udpPort.open();
Megnyitjuk az OSC kapcsolatot.
udpPort.on("ready", () => {
console.log("OSC vezérlő készen áll");
});
Amikor az OSC kapcsolat készen áll, egy üzenetet írunk a konzolra.
OSC Parancsok Küldése
Az alábbi függvények az OSC üzenetek küldését végzik:
setFile(filePath, bufferName)
function setFile(filePath, bufferName) {
udpPort.send({
address: "/setFile",
args: [filePath, bufferName]
});
console.log(`Fájl beállítva: ${filePath}, buffer: ${bufferName}`);
}
Egy fájl beállítását végzi egy adott buffer névre.
play(bufferName)
function play(bufferName) {
udpPort.send({
address: "/play",
args: [bufferName]
});
console.log(`Lejátszás indítása: ${bufferName}`);
}
Lejátszási parancs küldése egy adott buffer névre.
stop(fadeTime, bufferName)
function stop(fadeTime, bufferName) {
udpPort.send({
address: "/stop",
args: [fadeTime, bufferName]
});
console.log(`Lejátszás leállítása: ${bufferName}, fade-out: ${fadeTime}s`);
}
Leállítási parancs küldése egy adott bufferre, egy fade-out idővel.
OSC Üzenetek Fogadása
udpPort.on("message", (oscMsg) => {
if (oscMsg.address === "/playbackPosition") {
let time = Math.floor(oscMsg.args[0]);
let min = Math.floor(time / 60);
let sec = time % 60;
let formattedTime = `${min}:${sec.toString().padStart(2, '0')}`;
console.log(`Lejátszási pozíció: ${formattedTime}`);
// Küldjük az összes csatlakozott WebSocket kliensnek
wss.clients.forEach(client => {
if (client.readyState === WebSocket.OPEN) {
client.send(JSON.stringify({ type: "position", time: formattedTime }));
}
});
}
});
Ha egy /playbackPosition üzenetet kapunk:
- Az idő másodpercekben érkezik.
- Átalakítjuk percekké és másodpercekké.
- Kiírjuk a konzolra.
- Minden WebSocket kliensnek elküldjük az időt JSON formátumban.
WebSocket Szerver Beállítása
const WebSocket = require('ws');
Importáljuk a WebSocket modult.
const wss = new WebSocket.Server({ port: 8080 });
Létrehozunk egy WebSocket szervert a 8080-as porton.
wss.on("connection", (ws) => {
console.log("Új WebSocket kapcsolat");
Amikor egy új WebSocket kliens csatlakozik, kiírjuk a konzolra.
WebSocket Üzenetek Kezelése
ws.on("message", (message) => {
try {
const data = JSON.parse(message);
console.log("Kliens üzenet:", data);
Ha a kliens küld egy üzenetet, JSON-ként dolgozzuk fel.
if (data.command === "setFile") {
setFile(data.filePath, data.bufferName);
} else if (data.command === "play") {
play(data.bufferName);
} else if (data.command === "stop") {
stop(data.fadeTime, data.bufferName);
}
A beérkező parancsokat a megfelelő függvényekkel továbbítjuk az OSC szerver felé.
} catch (err) {
console.error("Hibás üzenet:", err);
}
});
Ha a JSON formátum hibás, hibaüzenetet írunk ki.
WebSocket Kapcsolat Bontása
ws.on("close", () => {
console.log("WebSocket kapcsolat bezárva");
});
Ha a kapcsolat megszakad, kiírjuk a konzolra.
WebSocket Szerver Indítása
console.log("WebSocket szerver elindítva a 8080-as porton.");
Induláskor egy üzenetet írunk ki a konzolra.
Összegzés
Ez a Node.js alkalmazás kétirányú kommunikációt biztosít:
- OSC-n keresztül SuperColliderhez csatlakozik, és fájlok betöltését, lejátszást, illetve leállítást vezérel.
- WebSocket szerverként működik, és kliensekkel kommunikál, lehetővé téve számukra az SC vezérlését és a lejátszási információk fogadását.
Az alkalmazás lehetővé teszi, hogy valós időben történjen a zenei fájlok lejátszása és vezérlése egy távoli SC szerveren keresztül.
Node.js indítása
pm2 start wss_osc.js --name osc-controller
Node.js környezet kialakítása
https://chatgpt.com/share/67acf90a-a484-8008-afc6-508c209dd448
https://chatgpt.com/share/67acf93c-3f0c-8008-8c0c-ac79c8ab96df
