Tech & GadgetsAI-generated

Ping, jitter en pakketverlies: wat je videocall merkt

Een snelheidstest meet vooral hoeveel megabit per seconde je lijn haalt. Voor een gesprek is dat zelden het probleem: de spraakcodec Opus werkt met 6 tot 510 kbit/s, een fractie van een gewone glasvezel- of kabelaansluiting. Wat je wel merkt, zijn haperingen en mensen die door elkaar heen praten. Die komen van drie andere getallen: ping, jitter en pakketverlies.

In dit artikel volgen we een geluidspakketje van microfoon naar oor. Je ziet waarom een belprogramma liever een pakket kwijtraakt dan erop wacht, hoe een jitterbuffer werkt en wat er met de vertraging gebeurde toen ik naast een ping-meting een grote download startte.

Van stem naar pakketjes

Een belprogramma knipt geluid in kleine stukjes en codeert elk stukje apart. Opus, dat elke WebRTC-toepassing volgens RFC 7874 moet ondersteunen, kan volgens RFC 6716 frames maken van 2,5 tot 60 milliseconden. De specificatie noemt 20 ms een goede keuze voor de meeste toepassingen. Bij 20 ms per pakket vertrekken er dus 50 pakketjes per seconde, in een strak ritme.

Langere frames zijn zuiniger, want je stuurt minder vaak headers mee. De RFC waarschuwt wel: elk pakket bevat dan meer geluid, dus het gesprek loopt verder achter en één verloren pakket kost een groter gat.

Waarom bellen niet op TCP wacht

Een download gaat meestal over TCP. Raakt daar een pakket kwijt, dan stuurt de zender het opnieuw, en de ontvanger houdt alles wat erna komt vast tot het gat gevuld is. Voor een bestand is dat goed, voor een gesprek niet: een herhaald pakket komt op zijn vroegst een volle rondreis later binnen, en tegen die tijd had dat stukje stem al afgespeeld moeten zijn.

Real-time audio en video gaan daarom meestal via RTP over UDP. RFC 3550 beschrijft RTP: elk pakket krijgt een volgnummer en een tijdstempel, zodat de ontvanger weet waar het in de stroom hoort en of er een ontbreekt. RTP zelf garandeert geen aflevering. Wat te laat is voor het afspeelmoment, is weg.

Ping: de vertraging die je niet wegkrijgt

Ping meet de rondreistijd: hoe lang een pakketje erover doet om heen en terug te gaan. Vanaf een Nederlandse verbinding stuurde ik 100 pings naar 1.1.1.1:

  • laagste: 11,6 ms
  • mediaan: 13,6 ms
  • hoogste: 24,0 ms
  • verlies: 0 procent

Voor een gesprek telt de vertraging in één richting, van mond tot oor. De ITU-aanbeveling G.114 zegt dat de meeste toepassingen onder de 150 ms "essentieel transparant" interactief aanvoelen, en noemt 400 ms als bovengrens voor netwerkplanning. Daarin zit alles: coderen, het netwerk, de buffer bij de ontvanger en het decoderen. Een groot deel van de netwerktijd is afstand, en daar valt weinig aan te doen, zoals het artikel over Sydney laat zien.

Jitter: pakketjes die niet in het ritme aankomen

De zender stuurt elke 20 ms een pakket, maar de ontvanger krijgt ze niet elke 20 ms. Het ene pakket staat even in de wachtrij van een router, het volgende niet. Die variatie in vertraging heet jitter.

RFC 3550 legt precies vast hoe een RTP-ontvanger jitter berekent. Je neemt het verschil in reistijd tussen twee opeenvolgende pakketten, en werkt daarmee een lopend gemiddelde bij:

J = J + (|D| - J) / 16

De deling door 16 maakt het een gladgestreken waarde: één uitschieter tilt J maar een klein stukje op. Ik heb die formule losgelaten op de 100 rondreistijden hierboven en kwam uit op 2,7 ms. RTP rekent strikt genomen met de reistijd in één richting, ping met de rondreis. Ping zelf toont mdev; volgens de handleiding is dat de standaardafwijking van de rondreistijden. Die was 2,0 ms.

De jitterbuffer: bewust een beetje wachten

Speel je elk pakket af zodra het binnenkomt, dan hoor je de jitter als haperingen. Daarom zet de ontvanger pakketten eerst in een jitterbuffer. Die houdt ze een vaste tijd vast en speelt ze daarna weer af in het oorspronkelijke ritme van 20 ms.

G.114 beschrijft de afweging. De buffer wordt zo groot gemaakt dat hij een bepaalde spreiding in vertraging opvangt. Een pakket dat later aankomt dan de buffer toestaat, wordt weggegooid, en voor de decoder is het dan gewoon verloren. Te grote jitter wordt dus pakketverlies. De prijs van de buffer is extra vertraging: G.114 rekent voor de planning met de helft van de buffergrootte. Een buffer voor 50 ms variatie voegt gemiddeld 25 ms toe aan het gesprek.

Wat een download met de wachtrij doet

Jitter ontstaat vooral in wachtrijen. Een download probeert de lijn vol te krijgen, en de router voor het smalste stuk zet het teveel in zijn buffer. Hoe TCP daarbij steeds tegen de rand duwt, staat in het artikel over TCP congestion control.

Ik pingde opnieuw naar 1.1.1.1, vijf keer per seconde, en startte na drie seconden een download van zo'n 700 Mbit/s die tien seconden liep:

mediaan95e percentielhoogstejitter (RFC 3550)
voor de download13,4 ms15,1 ms16,6 ms0,9 ms
tijdens de download17,8 ms23,6 ms30,0 ms4,8 ms
erna13,6 ms14,9 ms15,8 ms0,7 ms

Er ging geen pakket verloren, maar de jitter werd ruim vijf keer zo groot. Stel dat dit de pakketjes van een gesprek waren, met een jitterbuffer die rekent op de 13,4 ms van daarvoor. Van de 50 pings tijdens de download kwamen er 21 meer dan 5 ms later dan dat. Met 10 ms marge waren het er 4, met 15 ms nog 1, en pas met 20 ms marge kwam alles op tijd. Een kleine buffer betekent hier dus hoorbaar verlies, een grote buffer een trager gesprek.

Dit is nog een nette lijn. Een thuismodem met een grote buffer en een volle upload kan de vertraging veel verder laten oplopen. De oplossing zit in de router: een wachtrijbeheer als CoDel (RFC 8289) kijkt hoe lang pakketten in de wachtrij staan en begint te laten vallen als dat langer dan 100 ms boven de 5 ms blijft. TCP remt dan af en de wachtrij blijft kort.

Pakketverlies: gaten opvullen

Komt een pakket niet of te laat, dan heeft de ontvanger twee opties.

De eerste is verbergen. RFC 6716 noemt dat packet loss concealment: de decoder verzint een stukje geluid dat op het vorige lijkt. In de referentie-implementatie van Opus zoekt de ene modus de toonhoogte in het laatste geluid en herhaalt die golfvorm. De andere modus extrapoleert vanuit het vorige frame. Hoe langer het gat, hoe verder de decoder moet gokken.

De tweede is redundantie. In de spraakmodus (SILK) kan Opus in een pakket een extra, lager gecodeerde versie van het vorige frame meesturen (Low Bit-Rate Redundancy). Valt een pakket weg, dan haalt de ontvanger dat stukje uit het volgende pakket. Dat kost wat extra bandbreedte en werkt alleen als niet twee pakketten achter elkaar wegvallen.

Zelf proberen

Ping een tijdje met een korte tussenpoos en kijk naar de laatste regels:

ping -c 100 -i 0.2 1.1.1.1
100 packets transmitted, 100 received, 0% packet loss, time 19881ms
rtt min/avg/max/mdev = 11.588/14.173/24.031/1.957 ms

Start daarna in een tweede venster een grote download en draai dezelfde ping. Stijgen max en mdev flink, dan staat er ergens een volle wachtrij. Probeer het ook met een upload: dan vult de wachtrij aan jouw kant van de lijn.

Wil je de RTP-jitter zelf uitrekenen, sla de uitvoer dan op en laat Python de formule uit RFC 3550 toepassen:

ping -c 100 -i 0.2 1.1.1.1 > ping.txt
python3 -c "
import re
r=[float(x) for x in re.findall(r'time=([\d.]+)', open('ping.txt').read())]
J=0
for a,b in zip(r, r[1:]): J += (abs(b-a) - J) / 16
print(round(J, 1), 'ms')"
2.7 ms

Tot slot

Wat mij verraste, was dat de download geen enkel pakket kostte en toch het meest schadelijke getal was. Ping zag geen verlies, terwijl een belprogramma met een krappe jitterbuffer ruim vier op de tien van die pakketjes te laat had gekregen. Verlies en jitter zijn voor een gesprek uiteindelijk hetzelfde probleem: een pakket dat niet op tijd is, telt als kwijt.