ChannelSplitterNode — Schnittstelle · JavaScript-Referenz

Signatur

interface ChannelSplitterNode extends AudioNode

Beschreibung

ChannelSplitterNode ist ein Knoten der Web Audio API mit genau einem Eingang und mehreren Ausgängen. Jeder Kanal des Eingangssignals landet auf einem eigenen Mono-Ausgang: Kanal 0 (bei Stereo links) auf Ausgang 0, Kanal 1 (rechts) auf Ausgang 1 usw. Hat der Eingang weniger Kanäle als der Knoten Ausgänge, geben die überzähligen Ausgänge Stille aus.

Man braucht den Knoten immer dann, wenn einzelne Kanäle unterschiedlich behandelt werden sollen, zum Beispiel für getrennte Pegelanzeigen für links und rechts, eine eigene Lautstärke pro Kanal, das Vertauschen von Kanälen oder Effekte, die nur auf einer Seite wirken. Meist führt man die Kanäle danach mit einem ChannelMergerNode wieder zu einem Mehrkanalsignal zusammen.

Man erzeugt den Knoten entweder mit dem Konstruktor new ChannelSplitterNode(context, { numberOfOutputs }) oder mit der Fabrikmethode BaseAudioContext.createChannelSplitter(numberOfOutputs). Welcher Ausgang wohin geht, legt der zweite Parameter von connect(destination, outputIndex, inputIndex) fest.

Der Knoten hat keine eigenen Eigenschaften oder Methoden. Er erbt alles von AudioNode. Die Kanalkonfiguration ist fest vorgegeben: channelCount entspricht numberOfOutputs, channelCountMode ist "explicit" und channelInterpretation ist "discrete".

Parameter

Name	Typ	Default	Beschreibung
$context Pflicht	BaseAudioContext		Der `AudioContext` oder `OfflineAudioContext`, zu dem der Knoten gehört (nur beim Konstruktor).
$options	object	{}	Optionales Objekt für die Einstellungen (`ChannelSplitterOptions`). Es enthält `numberOfOutputs` und außerdem die geerbten Felder `channelCount`, `channelCountMode` und `channelInterpretation`. Diese müssen zu den fest vorgegebenen Werten passen.
$options.numberOfOutputs	number	6	Anzahl der Mono-Ausgänge, erlaubt sind 1 bis 32. Bei `createChannelSplitter(numberOfOutputs)` wird der Wert direkt als Argument übergeben.

Beispiele

Knoten erzeugen: Konstruktor und Fabrikmethode

const ctx = new AudioContext();

// Moderne Variante mit Konstruktor
const splitter = new ChannelSplitterNode(ctx, { numberOfOutputs: 2 });

// Gleichwertige Fabrikmethode
const splitter6 = ctx.createChannelSplitter(); // Standard: 6 Ausgänge

console.log(splitter.numberOfInputs, splitter.numberOfOutputs);
console.log(splitter6.numberOfOutputs, splitter6.channelCountMode, splitter6.channelInterpretation);

1 2 6 explicit discrete

Linken und rechten Kanal vertauschen

const ctx = new AudioContext();
const audio = document.querySelector('audio');
const source = ctx.createMediaElementSource(audio);

const splitter = new ChannelSplitterNode(ctx, { numberOfOutputs: 2 });
const merger = new ChannelMergerNode(ctx, { numberOfInputs: 2 });

source.connect(splitter);
// Ausgang 0 (links) -> Eingang 1 (rechts) und umgekehrt
splitter.connect(merger, 0, 1);
splitter.connect(merger, 1, 0);
merger.connect(ctx.destination);

// Autoplay-Regeln: Kontext erst nach einer Nutzeraktion starten
document.querySelector('#play').addEventListener('click', async () => {
  await ctx.resume();
  audio.play();
});

Getrennte Pegelanzeige für links und rechts

const ctx = new AudioContext();
const osc = new OscillatorNode(ctx, { frequency: 440 });
const panner = new StereoPannerNode(ctx, { pan: -0.8 }); // stark nach links
const splitter = new ChannelSplitterNode(ctx, { numberOfOutputs: 2 });

const analysers = [0, 1].map(() => new AnalyserNode(ctx, { fftSize: 1024 }));

osc.connect(panner).connect(splitter);
analysers.forEach((an, i) => splitter.connect(an, i)); // Ausgang i -> Analyser i
panner.connect(ctx.destination);

const rms = (an) => {
  const buf = new Float32Array(an.fftSize);
  an.getFloatTimeDomainData(buf);
  return Math.sqrt(buf.reduce((s, v) => s + v * v, 0) / buf.length);
};

osc.start();
setTimeout(() => {
  const [l, r] = analysers.map(rms);
  console.log(`L: ${l.toFixed(3)}  R: ${r.toFixed(3)}`);
  osc.stop();
}, 500);

L: 0.6xx R: 0.1xx (ungefähr; links deutlich lauter)

Nur den rechten Kanal leiser machen

const ctx = new AudioContext();
const osc = new OscillatorNode(ctx);
const stereo = new ChannelMergerNode(ctx, { numberOfInputs: 2 });
osc.connect(stereo, 0, 0);
osc.connect(stereo, 0, 1); // Mono auf beide Seiten verteilen

const splitter = new ChannelSplitterNode(ctx, { numberOfOutputs: 2 });
const rightGain = new GainNode(ctx, { gain: 0.2 });
const merger = new ChannelMergerNode(ctx, { numberOfInputs: 2 });

stereo.connect(splitter);
splitter.connect(merger, 0, 0);            // links unverändert
splitter.connect(rightGain, 1).connect(merger, 0, 1); // rechts gedämpft
merger.connect(ctx.destination);

osc.start();
osc.stop(ctx.currentTime + 1);

Siehe auch

ChannelMergerNode CanvasPattern AnalyserNode ConvolverNode PannerNode