RTCRemoteInboundRtpStreamStats.packetsReceived — Eigenschaft · JavaScript-Referenz

Signatur

RTCRemoteInboundRtpStreamStats.packetsReceived

Beschreibung

Die Eigenschaft packetsReceived eines RTCRemoteInboundRtpStreamStats-Objekts (Statistiktyp "remote-inbound-rtp") gibt an, wie viele RTP-Pakete der entfernte Teilnehmer von der Synchronisationsquelle (SSRC) empfangen hat, die du lokal sendest. Die Zahl ist ein fortlaufender Zähler seit Beginn des Streams. Sie stammt aus der Sicht des Empfängers und wird dir über RTCP-Berichte (Receiver Reports) übermittelt.

Die Eigenschaft ist von RTCReceivedRtpStreamStats geerbt. Laut Spezifikation zählen auch erneut übertragene Pakete (Retransmissions) mit. Da die Daten per RTCP ankommen, hinken sie den lokalen Zahlen etwas hinterher, typischerweise um einige hundert Millisekunden bis wenige Sekunden.

In der Praxis nutzt du den Wert, um die Übertragungsqualität in Senderichtung zu überwachen. Du vergleichst ihn mit packetsSent aus dem passenden "outbound-rtp"-Eintrag oder betrachtest ihn zusammen mit packetsLost und fractionLost. So erkennst du, ob deine Medien beim Gegenüber ankommen, und kannst zum Beispiel die Bitrate senken oder dem Nutzer einen Hinweis auf eine schlechte Verbindung zeigen.

Du bekommst den Wert über RTCPeerConnection.getStats() oder RTCRtpSender.getStats(). In der zurückgegebenen RTCStatsReport-Map filterst du nach type === "remote-inbound-rtp".

Rückgabewert

Typ

number | undefined

Beschreibung

Nicht-negative Ganzzahl (in der Spezifikation unsigned long long): die Gesamtzahl der RTP-Pakete, die der entfernte Endpunkt für diese SSRC empfangen hat. undefined, wenn der Browser das Feld nicht ausfüllt.

Beispiele

Empfangene Pakete beim Gegenüber auslesen

// pc ist eine bestehende, verbundene RTCPeerConnection
const logRemoteReceived = async (pc) => {
  const report = await pc.getStats();
  report.forEach((stats) => {
    if (stats.type === 'remote-inbound-rtp') {
      console.log(`${stats.kind}: Gegenüber hat ${stats.packetsReceived ?? 'k. A.'} Pakete empfangen`);
    }
  });
};

logRemoteReceived(pc);

audio: Gegenüber hat 4821 Pakete empfangen video: Gegenüber hat 15377 Pakete empfangen

Gesendete und beim Gegenüber angekommene Pakete vergleichen

const compareDelivery = async (sender) => {
  const report = await sender.getStats();
  let outbound, remoteInbound;
  report.forEach((s) => {
    if (s.type === 'outbound-rtp') outbound = s;
    if (s.type === 'remote-inbound-rtp') remoteInbound = s;
  });
  if (!outbound || remoteInbound?.packetsReceived === undefined) {
    console.log('Noch keine RTCP-Daten verfügbar');
    return;
  }
  const ratio = remoteInbound.packetsReceived / outbound.packetsSent;
  console.log(`Zustellquote: ${(ratio * 100).toFixed(1)} %`);
};

const [videoSender] = pc.getSenders().filter((s) => s.track?.kind === 'video');
compareDelivery(videoSender);

Zustellquote: 98.7 %

Empfangsrate laufend überwachen (Differenzen pro Intervall)

const monitor = (pc, intervalMs = 2000) => {
  const last = new Map();
  const timer = setInterval(async () => {
    const report = await pc.getStats();
    report.forEach((s) => {
      if (s.type !== 'remote-inbound-rtp' || s.packetsReceived === undefined) return;
      const prev = last.get(s.id);
      if (prev) {
        const deltaPackets = s.packetsReceived - prev.packetsReceived;
        const deltaSec = (s.timestamp - prev.timestamp) / 1000;
        console.log(`${s.kind}: ${(deltaPackets / deltaSec).toFixed(0)} Pakete/s beim Gegenüber`);
      }
      last.set(s.id, { packetsReceived: s.packetsReceived, timestamp: s.timestamp });
    });
  }, intervalMs);
  return () => clearInterval(timer); // Stopp-Funktion
};

const stopMonitor = monitor(pc);

audio: 50 Pakete/s beim Gegenüber video: 312 Pakete/s beim Gegenüber

// Wichtig · Fallstricke

Browserunterstützung: Nicht jeder Browser füllt packetsReceived in "remote-inbound-rtp"-Statistiken aus, denn RTCP-Receiver-Reports enthalten diesen Wert nicht direkt. Prüfe deshalb immer auf undefined und leite die Zahl bei Bedarf aus packetsSent - packetsLost ab.
Verzögerung: Der Wert wird nur aktualisiert, wenn ein RTCP-Bericht ankommt. Direkt nach dem Verbindungsaufbau fehlt der "remote-inbound-rtp"-Eintrag oft ganz.
Retransmissions: Erneut übertragene Pakete werden mitgezählt. Der Zähler kann deshalb höher sein als die Zahl der eindeutigen Pakete, und ein direkter Vergleich mit packetsSent ist nur eine Näherung.
Zähler statt Rate: Der Wert steigt seit Stream-Beginn stetig an. Für aussagekräftige Messungen bildest du Differenzen zwischen zwei Abfragen und nutzt dafür timestamp.
Ordne Einträge über localId bzw. remoteId einander zu, wenn mehrere Streams (Simulcast, mehrere Tracks) aktiv sind.

Siehe auch

RTCRemoteInboundRtpStreamStats RTCRemoteInboundRtpStreamStats.packetsLost RTCRemoteInboundRtpStreamStats.fractionLost RTCOutboundRtpStreamStats.packetsSent RTCPeerConnection.getStats() RTCStatsReport RTCRemoteInboundRtpStreamStats.transportId