WebRTC Troubleshooting

// Dump all stats to console
const report = await pc.getStats();
report.forEach(stat => console.log(stat.type, stat));

// Targeted queries
async function printConnectionStats(pc) {
  const report = await pc.getStats();

  for (const stat of report.values()) {
    switch (stat.type) {
      case 'candidate-pair':
        if (stat.nominated) {
          console.log('Nominated pair:');
          console.log('  RTT:', stat.currentRoundTripTime * 1000, 'ms');
          console.log('  Bytes sent:', stat.bytesSent);
          console.log('  Bytes received:', stat.bytesReceived);
          console.log('  Available outgoing bandwidth:',
            stat.availableOutgoingBitrate / 1000, 'kbps');
        }
        break;

      case 'inbound-rtp':
        console.log(`Inbound ${stat.kind}:`);
        console.log('  Packets lost:', stat.packetsLost);
        console.log('  Jitter:', stat.jitter * 1000, 'ms');
        console.log('  Frames dropped:', stat.framesDropped);
        console.log('  Decode time:', stat.totalDecodeTime / stat.framesDecoded * 1000, 'ms/frame');
        break;

      case 'outbound-rtp':
        console.log(`Outbound ${stat.kind}:`);
        console.log('  Bytes sent:', stat.bytesSent);
        console.log('  Retransmitted bytes:', stat.retransmittedBytesSent);
        console.log('  FPS:', stat.framesPerSecond);
        console.log('  QP (quality):', stat.qpSum / stat.framesEncoded);
        break;

      case 'local-candidate':
        console.log('Local candidate type:', stat.candidateType, stat.protocol);
        break;

      case 'remote-candidate':
        console.log('Remote candidate type:', stat.candidateType, stat.protocol);
        break;
    }
  }
}

// Diagnose: what candidate types were gathered?
const report = await pc.getStats();
const localCandidates = [...report.values()].filter(r => r.type === 'local-candidate');
console.log(localCandidates.map(c => `${c.candidateType} ${c.protocol} ${c.address}:${c.port}`));
// If you only see 'host' candidates — STUN is not working
// If you see no 'relay' candidates — TURN is not configured or not reachable

// Check if ontrack fired
pc.ontrack = (e) => {
  console.log('Got track:', e.track.kind, e.track.readyState);
  // If track.readyState is 'ended' immediately, the sender stopped it
};

// Check that remote description was set
console.log('Remote desc:', pc.remoteDescription);

// Check transceiver directions
pc.getTransceivers().forEach(t => {
  console.log(t.mid, 'direction:', t.direction, 'currentDirection:', t.currentDirection);
  // If currentDirection is 'inactive' or 'sendonly', remote is not sending
});

// Check signaling was completed correctly
console.log('Local desc type:', pc.localDescription?.type);   // 'offer' | 'answer'
console.log('Remote desc type:', pc.remoteDescription?.type); // must be the opposite

// Check ICE candidate count
const report = await pc.getStats();
const pairs = [...report.values()].filter(r => r.type === 'candidate-pair');
console.log('Candidate pairs tried:', pairs.length);
// 0 pairs = no candidates were exchanged

// Guard with makingOffer flag
let makingOffer = false;
pc.onnegotiationneeded = async () => {
  if (makingOffer || pc.signalingState !== 'stable') return;
  makingOffer = true;
  try {
    await pc.setLocalDescription(await pc.createOffer());
    signaling.send({ type: 'offer', sdp: pc.localDescription });
  } finally {
    makingOffer = false;
  }
};

// For local preview: always mute the local video element
localVideo.muted = true;

// Ensure echo cancellation is on in getUserMedia
const stream = await navigator.mediaDevices.getUserMedia({
  audio: { echoCancellation: true, noiseSuppression: true },
});

// Do NOT route remote audio to a Web Audio node and then back into getUserMedia

setInterval(async () => {
  const report = await pc.getStats();
  for (const stat of report.values()) {
    if (stat.type === 'inbound-rtp' && stat.kind === 'video') {
      const lossRate = stat.packetsLost / (stat.packetsReceived + stat.packetsLost);
      console.log('Packet loss:', (lossRate * 100).toFixed(1), '%');
      console.log('Jitter:', stat.jitter * 1000, 'ms');
      // > 5% loss → severe quality degradation
      // > 30 ms jitter → consider jitter buffer tuning
    }
  }
}, 2000);

// Quick test: can we reach the STUN server and get a reflexive candidate?
async function testStun(stunUrl) {
  return new Promise((resolve, reject) => {
    const pc = new RTCPeerConnection({ iceServers: [{ urls: stunUrl }] });
    pc.createDataChannel('test');

    const candidates = [];
    pc.onicecandidate = ({ candidate }) => {
      if (!candidate) {
        pc.close();
        const hasSrflx = candidates.some(c => c.type === 'srflx');
        resolve({ reachable: hasSrflx, candidates });
      } else {
        candidates.push(candidate);
      }
    };

    pc.onicecandidateerror = (e) => reject(new Error(`${e.errorCode}: ${e.errorText}`));

    pc.createOffer().then(o => pc.setLocalDescription(o));
    setTimeout(() => { pc.close(); reject(new Error('Timeout')); }, 5000);
  });
}

const result = await testStun('stun:stun.l.google.com:19302');
console.log('STUN reachable:', result.reachable);

// Print human-readable SDP sections
function parseSdpMedia(sdp) {
  return sdp.split('\nm=').slice(1).map(section => {
    const lines = section.split('\n');
    const kind = lines[0].split(' ')[0];
    const codecs = lines
      .filter(l => l.startsWith('a=rtpmap'))
      .map(l => l.replace('a=rtpmap:', ''));
    return { kind, codecs };
  });
}

console.log(parseSdpMedia(pc.localDescription.sdp));

// Force a specific maximum bitrate via SDP munging (not recommended but sometimes needed)
function setMaxBitrate(sdp, bitrateBps) {
  return sdp.replace(/b=AS:\d+/g, `b=AS:${Math.floor(bitrateBps / 1000)}`);
}

// Prefer: use RTCRtpSender.setParameters
const sender = pc.getSenders().find(s => s.track?.kind === 'video');
const params = sender.getParameters();
params.encodings[0].maxBitrate = 500_000; // 500 kbps hard cap
await sender.setParameters(params);