testing/web-platform/tests/webrtc/RTCRtpReceiver-getSynchronizationSources.https.html

   1 <!doctype html>
   2 <meta charset=utf-8>
   3 <!-- This file contains two tests that wait for 10 seconds each. -->
   4 <meta name="timeout" content="long">
   5 <title>RTCRtpReceiver.prototype.getSynchronizationSources</title>
   6 <script src="/resources/testharness.js"></script>
   7 <script src="/resources/testharnessreport.js"></script>
   8 <script src="RTCPeerConnection-helper.js"></script>
   9 <script>
  10 'use strict';
  11
  12 async function initiateSingleTrackCallAndReturnReceiver(t, kind) {
  13   const pc1 = new RTCPeerConnection();
  14   t.add_cleanup(() => pc1.close());
  15   const pc2 = new RTCPeerConnection();
  16   t.add_cleanup(() => pc2.close());
  17
  18   const stream = await getNoiseStream({[kind]:true});
  19   const [track] = stream.getTracks();
  20   t.add_cleanup(() => track.stop());
  21   pc1.addTrack(track, stream);
  22
  23   exchangeIceCandidates(pc1, pc2);
  24   const trackEvent = await exchangeOfferAndListenToOntrack(t, pc1, pc2);
  25   await exchangeAnswer(pc1, pc2);
  26   return trackEvent.receiver;
  27 }
  28
  29 for (const kind of ['audio', 'video']) {
  30   promise_test(async t => {
  31     const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
  32     await listenForSSRCs(t, receiver);
  33   }, '[' + kind + '] getSynchronizationSources() eventually returns a ' +
  34      'non-empty list');
  35
  36   promise_test(async t => {
  37     const startTime = performance.now();
  38     const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
  39     const [ssrc] = await listenForSSRCs(t, receiver);
  40     assert_equals(typeof ssrc.timestamp, 'number');
  41     assert_true(ssrc.timestamp >= startTime);
  42   }, '[' + kind + '] RTCRtpSynchronizationSource.timestamp is a number');
  43
  44   promise_test(async t => {
  45     const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
  46     const [ssrc] = await listenForSSRCs(t, receiver);
  47     assert_equals(typeof ssrc.rtpTimestamp, 'number');
  48     assert_greater_than_equal(ssrc.rtpTimestamp, 0);
  49     assert_less_than_equal(ssrc.rtpTimestamp, 0xffffffff);
  50   }, '[' + kind + '] RTCRtpSynchronizationSource.rtpTimestamp is a number ' +
  51      '[0, 2^32-1]');
  52
  53   promise_test(async t => {
  54     const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
  55     // Wait for packets to start flowing.
  56     await listenForSSRCs(t, receiver);
  57     // Wait for 10 seconds.
  58     await new Promise(resolve => t.step_timeout(resolve, 10000));
  59     let earliestTimestamp = undefined;
  60     let latestTimestamp = undefined;
  61     for (const ssrc of await listenForSSRCs(t, receiver)) {
  62       if (earliestTimestamp == undefined || earliestTimestamp > ssrc.timestamp)
  63         earliestTimestamp = ssrc.timestamp;
  64       if (latestTimestamp == undefined || latestTimestamp < ssrc.timestamp)
  65         latestTimestamp = ssrc.timestamp;
  66     }
  67     assert_true(latestTimestamp - earliestTimestamp <= 10000);
  68   }, '[' + kind + '] getSynchronizationSources() does not contain SSRCs ' +
  69      'older than 10 seconds');
  70
  71   promise_test(async t => {
  72     const startTime = performance.timeOrigin + performance.now();
  73     const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
  74     const [ssrc] = await listenForSSRCs(t, receiver);
  75     const endTime = performance.timeOrigin + performance.now();
  76     assert_true(startTime <= ssrc.timestamp && ssrc.timestamp <= endTime);
  77   }, '[' + kind + '] RTCRtpSynchronizationSource.timestamp is comparable to ' +
  78      'performance.timeOrigin + performance.now()');
  79
  80   promise_test(async t => {
  81     const receiver = await initiateSingleTrackCallAndReturnReceiver(t, kind);
  82     const [ssrc] = await listenForSSRCs(t, receiver);
  83     assert_equals(typeof ssrc.source, 'number');
  84   }, '[' + kind + '] RTCRtpSynchronizationSource.source is a number');
  85 }
  86
  87 promise_test(async t => {
  88   const receiver = await initiateSingleTrackCallAndReturnReceiver(t, 'audio');
  89   const [ssrc] = await listenForSSRCs(t, receiver);
  90   assert_equals(typeof ssrc.audioLevel, 'number');
  91   assert_greater_than_equal(ssrc.audioLevel, 0);
  92   assert_less_than_equal(ssrc.audioLevel, 1);
  93 }, '[audio-only] RTCRtpSynchronizationSource.audioLevel is a number [0, 1]');
  94
  95 // This test only passes if the implementation is sending the RFC 6464 extension
  96 // header and the "vad" extension attribute is not "off", otherwise
  97 // voiceActivityFlag is absent. TODO: Consider moving this test to an
  98 // optional-to-implement subfolder?
  99 promise_test(async t => {
 100   const receiver = await initiateSingleTrackCallAndReturnReceiver(t, 'audio');
 101   const [ssrc] = await listenForSSRCs(t, receiver);
 102   assert_equals(typeof ssrc.voiceActivityFlag, 'boolean');
 103 }, '[audio-only] RTCRtpSynchronizationSource.voiceActivityFlag is a boolean');
 104
 105 </script>