Spraakgesprekken en audioruimtes in een webapp: hoe ze werken

Een spraakgesprek in een webapp is een WebRTC-gesprek met een microfoontrack en zonder camera: dezelfde verbinding als een videogesprek, die een paar tientallen kilobits per seconde vervoert in plaats van honderden. Een audioruimte is een groepsgesprek waarin een paar mensen spreken en alle anderen luisteren, en daarvoor zijn een mediaserver nodig en een regel op je server over wie mag spreken.
Allebei zijn het gesprekken tussen de gebruikers van je app, via hun accounts, over het internet. Er zitten geen telefoonnummers en geen telefoonnet in. Dit artikel laat zien wat een spraakgesprek verstuurt, gemeten in Chromium, welke browsercode het nodig heeft, hoe een audioruimte verschilt van een gesprek tussen twee, en hoe een app ze allebei toevoegt zonder de mediakant zelf te bouwen.
Een spraakgesprek is een videogesprek zonder camera
Elke browser die WebRTC spreekt, moet twee audiocodecs ondersteunen: Opus, en G.711 als PCMA en PCMU voor oudere telefoonsystemen (RFC 7874). Waar beide kanten het kunnen, gaat Opus voor. Opus dekt alles van 6 kbit/s voor smalbandige spraak tot 510 kbit/s voor stereomuziek, en de eigen specificatie noemt 16 tot 20 kbit/s als het ideale bereik voor breedbandige spraak (RFC 6716).
We zetten een gesprek met alleen audio op tussen twee verbindingen in Chromium 156, met de nepmicrofoon, en lazen wat de zender rapporteerde:
| Gemeten | Spraak | Video |
|---|---|---|
| Codec | Opus, 48 kHz, mono | VP8 |
| Geluid of beeld | ongeveer 21 kbit/s | bijna 480 kbit/s |
| RTP-headers | ongeveer 12 kbit/s |
Het spraakgesprek verstuurde 50 pakketjes per seconde, één voor elke 20 milliseconden geluid, en de headers van die pakketjes kwamen op meer dan de helft van het geluid erin. IP en UDP voegen op de lijn nog meer toe. Het videogesprek, een beeld van 640 bij 480 van de nepcamera, zat na 20 seconden bijna op 480 kbit/s en klom nog steeds terwijl de browser meer ruimte vond, dus dat getal zegt meer over het begin van een gesprek dan over het einde.
Een spraakgesprek vervoert dus veel minder bits dan een videogesprek, en daarom houdt het stand op een zwak mobiel netwerk waar video hapert. Al het andere is hetzelfde: een aanbieding en een antwoord, de adressen van beide kanten, en een relay voor netwerken die een direct pad blokkeren.
De browsercode
Een spraakgesprek vraagt alleen om de microfoon, en speelt wat terugkomt af in een <audio>-element:
// call.js: de microfoon, met echo-onderdrukking, ruisonderdrukking en niveauregeling van de browser gevraagd
const stream = await navigator.mediaDevices.getUserMedia({
audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true },
});
const pc = new RTCPeerConnection({ iceServers: [{ urls: 'stun:stun.example.com:3478' }] });
pc.addTrack(stream.getAudioTracks()[0], stream);
pc.ontrack = ({ streams }) => {
const audio = document.getElementById('them');
audio.srcObject = streams[0];
// Een browser speelt pas geluid af nadat iemand op de pagina heeft geklikt of getypt.
audio.play().catch(() => showTurnSoundOn());
};
// Dempen: de track loopt door, en de andere kant hoort stilte.
document.getElementById('mute').onclick = () => {
const track = stream.getAudioTracks()[0];
track.enabled = !track.enabled;
};<audio id="them" autoplay></audio>
<button id="mute">Mute</button>De aanbieding, het antwoord en de kandidaten gaan via een signalingserver, precies zoals bij video: hoe WebRTC twee browsers verbindt bevat die relay, een paar regels Node.js, en de pagina eromheen. Drie dingen tellen zwaarder in een spraakgesprek dan in een videogesprek:
- Echo. Zonder headset speelt de speaker van een laptop de ander af in zijn eigen microfoon. RFC 7874 vraagt elk WebRTC-eindpunt die echo te onderdrukken, en in Chromium stonden alle drie de opties hierboven standaard aan toen we
track.getSettings()lazen op een gewone{ audio: true }. Vraag er toch om, en laat ze aan, tenzij de app muziek afspeelt. - Geluid dat niet begint. Browsers houden geluid tegen tot iemand de pagina heeft gebruikt. Een gesprek dat met een klik wordt aangenomen, gaat goed. Een gesprek dat begint vanaf een link in een nieuw tabblad kan in stilte verbinden, dus geef de pagina een knop die het geluid start als
play()weigert. - Dempen zonder op te hangen. Met
track.enableduit gaat er stilte en blijft de verbinding staan, dus weer aanzetten gaat meteen en vraagt nergens om. De track stoppen zou betekenen dat je opnieuw om de microfoon moet vragen.
Is de microfoon zelf het probleem, dan zoekt de microfoontest uit welk deel faalt, in de browser, nog voor er een gesprek is.
Een audioruimte is een groepsgesprek met luisteraars
Een gesprek tussen twee mensen gaat van de ene browser naar de andere. Een ruimte met twintig mensen kan zo niet werken: in een mesh stuurt elke spreker een kopie van zijn stem naar elke andere persoon, dus de upload groeit met iedereen die erbij komt. Groepsgesprekken sturen elke stem één keer naar een mediaserver, die hem doorstuurt naar alle anderen (hoe groepsvideogesprekken werken).
Een audioruimte voegt daar rollen aan toe:
| Twee mensen | Audioruimte | |
|---|---|---|
| Wie spreekt | allebei | de sprekers, een paar |
| Waar geluid heen gaat | van browser naar browser | via een mediaserver |
| Wie beslist | de twee zelf | de host en je server |
De luisteraars versturen helemaal niets. Ze ontvangen de stemmen van de sprekers, elk doorgestuurd door de server, en hun microfoons blijven dicht. Een luisteraar steekt een hand op, de host laat hem spreken, en maakt hem later weer luisteraar.
Dat laatste moet op een server beslist worden. Een knop die de microfoon alleen in de pagina verbergt, is geen regel: iedereen kan de console van de browser openen en toch geluid versturen. De mediaserver moet weigeren wat een luisteraar verstuurt, en het terugnemen van iemand die geen spreker meer is, op grond van een bewijs dat alleen jouw server kan geven.
Wat nog steeds geldt
Zonder camera bespaar je bandbreedte en verder niets. Een spraakgesprek heeft nog steeds nodig:
- STUN en TURN. Sommige netwerken blokkeren een direct pad tussen twee apparaten, voor spraak net als voor video. Een relay op poort 443 haalt die gesprekken erdoor (STUN- en TURN-servers uitgelegd).
- Het overgaan. Wie gebeld wordt, moet het horen in welk tabblad of op welk apparaat hij ook open heeft, en het in de andere niet meer horen zodra hij opneemt.
- Een verbinding die een wissel overleeft. Een telefoon die van wifi naar mobiele data gaat, verliest het pad waarover het gesprek liep, dus het gesprek moet een nieuw pad vinden zonder op te hangen.
Spraakgesprekken en audioruimtes met WordPlus Cloud
Met het pakket @wordplus/realtime is een spraakgesprek een videogesprek met type: 'audio'. Je app beslist wie wie mag bellen in een eigen route, die een token voor het gesprek teruggeeft. In Express:
// server.mjs: GET /call-token?to=34&type=audio, die de knop opvraagt als erop wordt gedrukt.
app.get('/call-token', async (req, res) => {
// Hier komt je eigen controle: wie wie mag bellen.
const me = req.session.userId;
if (!me) return res.sendStatus(401);
res.json({ token: await realtime.callToken(me, req.query.to, { type: req.query.type }) });
});await rt.callScreen(); // het overgaan en het gespreksvenster, op elke pagina waar een gesprek kan binnenkomen<call-button to="34" token-url="/call-token" type="audio" name="Ann">Call Ann</call-button>Het gesprek gaat over in elk tabblad en op elk apparaat dat Ann open heeft. Het gaat rechtstreeks tussen de twee browsers als hun netwerken dat toelaten, via onze relays op de poorten 443 en 80 als dat niet zo is, en via onze mediaservers als zelfs die er niet doorkomen, en het wisselt van de ene weg naar de andere zonder op te hangen. Gesprekken tussen twee mensen zijn op elke weg end-to-end versleuteld, en kosten op geen enkele weg credits.
Een audioruimte is een groepsgesprek waarvan de tokens type: 'audio' zeggen, met publish: false voor de luisteraars. Hier spreekt de host van ruimte 7 en leidt hij die, en luisteren de anderen tot ze mogen spreken:
// GET /room-token?id=7, die <group-call-button call="room:7" token-url="/room-token?id=7" type="audio"> opvraagt.
app.get('/room-token', async (req, res) => {
const me = req.session.userId;
if (!me) return res.sendStatus(401);
const host = await isHostOf(req.query.id, me); // van jou, uit je eigen data
res.json({
token: await realtime.groupCallToken(me, `room:${req.query.id}`, {
type: 'audio',
admin: host,
publish: host || (await maySpeak(req.query.id, me)),
}),
});
});
// De host laat iemand spreken, of maakt hem weer luisteraar, terwijl de ruimte loopt.
await realtime.call('room:7').permit(34, { publish: true });Het belscherm geeft de host bij elke persoon Promote to Speaker en Demote to Viewer, en de mediaservers weigeren geluid van iedereen die je token of permit() luisteraar heeft gemaakt. Een groepsgesprek is end-to-end versleuteld als de tokens encrypt: true zeggen. In groepsgesprekken kost een aantal mensen tegelijk op video met je abonnement geen credits, waarbij iemand op audio voor de helft telt, en elke persoon daarboven kost een credit per minuut, op audio de helft (limieten). Waar een maand gesprekken op uitkomt: hoe je de kosten van videogesprekken inschat.
Lessen, webinars en audioruimtes laat opgestoken handen en een eigen knop om iemand te laten spreken zien in Node, PHP en Python, en de gesprekspagina van de Express-handleiding de rest: wie mag bellen, een eigen gespreksinterface, en gesprekken in een chat.
Spraakgesprekken voor je app
WordPlus Cloud for Apps is geprijsd op gelijktijdige verbindingen, vanaf 1.000, maandelijks of jaarlijks gefactureerd, en gesprekken tussen twee mensen kosten op geen enkele weg credits. Bekijk gesprekken en groepsgesprekken voor apps, of de prijzen voor apps. Vragen over je integratie? Schrijf ons.