DXR is a code search and navigation tool aimed at making sense of large projects. It supports full-text and regex searches as well as structural queries.

Mercurial (6663d3dc883b)

VCS Links

Line Code
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105
<!doctype html>
<meta charset=utf-8>
<!-- This file contains two tests that wait for 10 seconds each. -->
<meta name="timeout" content="long">
<title>RTCRtpReceiver.prototype.getSynchronizationSources</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="RTCPeerConnection-helper.js"></script>
<script>
'use strict';

async function initiateSingleTrackCallAndReturnReceiver(t, kind) {
  const pc1 = new RTCPeerConnection();
  t.add_cleanup(() => pc1.close());
  const pc2 = new RTCPeerConnection();
  t.add_cleanup(() => pc2.close());

  const stream = await getNoiseStream({[kind]:true});
  const [track] = stream.getTracks();
  t.add_cleanup(() => track.stop());
  pc1.addTrack(track, stream);

  exchangeIceCandidates(pc1, pc2);
  const trackEvent = await exchangeOfferAndListenToOntrack(t, pc1, pc2);
  await exchangeAnswer(pc1, pc2);
  return trackEvent.receiver;
}

for (const kind of ['audio', 'video']) {
  promise_test(async t => {
    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
    await listenForSSRCs(t, receiver);
  }, '[' + kind + '] getSynchronizationSources() eventually returns a ' +
     'non-empty list');

  promise_test(async t => {
    const startTime = performance.now();
    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
    const [ssrc] = await listenForSSRCs(t, receiver);
    assert_equals(typeof ssrc.timestamp, 'number');
    assert_true(ssrc.timestamp >= startTime);
  }, '[' + kind + '] RTCRtpSynchronizationSource.timestamp is a number');

  promise_test(async t => {
    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
    const [ssrc] = await listenForSSRCs(t, receiver);
    assert_equals(typeof ssrc.rtpTimestamp, 'number');
    assert_greater_than_equal(ssrc.rtpTimestamp, 0);
    assert_less_than_equal(ssrc.rtpTimestamp, 0xffffffff);
  }, '[' + kind + '] RTCRtpSynchronizationSource.rtpTimestamp is a number ' +
     '[0, 2^32-1]');

  promise_test(async t => {
    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
    // Wait for packets to start flowing.
    await listenForSSRCs(t, receiver);
    // Wait for 10 seconds.
    await new Promise(resolve => t.step_timeout(resolve, 10000));
    let earliestTimestamp = undefined;
    let latestTimestamp = undefined;
    for (const ssrc of await listenForSSRCs(t, receiver)) {
      if (earliestTimestamp == undefined || earliestTimestamp > ssrc.timestamp)
        earliestTimestamp = ssrc.timestamp;
      if (latestTimestamp == undefined || latestTimestamp < ssrc.timestamp)
        latestTimestamp = ssrc.timestamp;
    }
    assert_true(latestTimestamp - earliestTimestamp <= 10000);
  }, '[' + kind + '] getSynchronizationSources() does not contain SSRCs ' +
     'older than 10 seconds');

  promise_test(async t => {
    const startTime = performance.timeOrigin + performance.now();
    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
    const [ssrc] = await listenForSSRCs(t, receiver);
    const endTime = performance.timeOrigin + performance.now();
    assert_true(startTime <= ssrc.timestamp && ssrc.timestamp <= endTime);
  }, '[' + kind + '] RTCRtpSynchronizationSource.timestamp is comparable to ' +
     'performance.timeOrigin + performance.now()');

  promise_test(async t => {
    const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
    const [ssrc] = await listenForSSRCs(t, receiver);
    assert_equals(typeof ssrc.source, 'number');
  }, '[' + kind + '] RTCRtpSynchronizationSource.source is a number');
}

promise_test(async t => {
  const receiver = await initiateSingleTrackCallAndReturnReceiver(t, 'audio');
  const [ssrc] = await listenForSSRCs(t, receiver);
  assert_equals(typeof ssrc.audioLevel, 'number');
  assert_greater_than_equal(ssrc.audioLevel, 0);
  assert_less_than_equal(ssrc.audioLevel, 1);
}, '[audio-only] RTCRtpSynchronizationSource.audioLevel is a number [0, 1]');

// This test only passes if the implementation is sending the RFC 6464 extension
// header and the "vad" extension attribute is not "off", otherwise
// voiceActivityFlag is absent. TODO: Consider moving this test to an
// optional-to-implement subfolder?
promise_test(async t => {
  const receiver = await initiateSingleTrackCallAndReturnReceiver(t, 'audio');
  const [ssrc] = await listenForSSRCs(t, receiver);
  assert_equals(typeof ssrc.voiceActivityFlag, 'boolean');
}, '[audio-only] RTCRtpSynchronizationSource.voiceActivityFlag is a boolean');

</script>