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
|
<!doctype html>
<meta charset=utf-8>
<meta name="timeout" content="long">
<title>RTCPeerConnection Video detector test</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="RTCPeerConnection-helper.js"></script>
<script>
'use strict';
// This test verifies that the helper function "detectSignal" from
// RTCPeerConnectionHelper, which is used to detect changes in a video
// signal, performs properly for a range of "signal" values.
// If it fails, it indicates that the video codec used in this particular
// browser at this time doesn't reproduce the luma signal reliably enough
// for this particular application, which may lead to other tests that
// use the "detectSignal" helper failing without an obvious cause.
// The most likely failure is timeout - which will happen if the
// luma value detected doesn't settle within the margin of error before
// the test times out.
async function signalSettlementTime(t, v, sender, signal, backgroundTrack) {
const detectionStream = await getNoiseStream({video: {signal}});
const [detectionTrack] = detectionStream.getTracks();
try {
await sender.replaceTrack(detectionTrack);
const framesBefore = v.getVideoPlaybackQuality().totalVideoFrames;
await detectSignal(t, v, signal);
const framesAfter = v.getVideoPlaybackQuality().totalVideoFrames;
await sender.replaceTrack(backgroundTrack);
await detectSignal(t, v, 100);
return framesAfter - framesBefore;
} finally {
detectionTrack.stop();
}
}
promise_test(async t => {
const v = document.createElement('video');
v.autoplay = true;
const pc1 = new RTCPeerConnection();
const pc2 = new RTCPeerConnection();
t.add_cleanup(() => pc1.close());
t.add_cleanup(() => pc2.close());
const stream1 = await getNoiseStream({video: {signal: 100}});
const [track1] = stream1.getTracks();
t.add_cleanup(() => track1.stop());
const sender = pc1.addTrack(track1);
const haveTrackEvent = new Promise(r => pc2.ontrack = r);
exchangeIceCandidates(pc1, pc2);
await exchangeOfferAnswer(pc1, pc2);
v.srcObject = new MediaStream([(await haveTrackEvent).track]);
await new Promise(r => v.onloadedmetadata = r);
// The basic signal is a track with signal 100. We replace this
// with tracks with signal from 0 to 255 and see if they are all
// reliably detected.
await detectSignal(t, v, 100);
// A few buffered frames are received with the old content, and a few
// frames may not have settled on exactly the right value. In testing,
// this test passes with maxFrames = 3; give a little more margin.
const maxFrames = 7;
// Test values 0 and 255
let maxCount = await signalSettlementTime(t, v, sender, 0, track1);
assert_less_than(maxCount, maxFrames,
'Should get the black value within ' + maxFrames + ' frames');
maxCount = Math.max(
await signalSettlementTime(t, v, sender, 255, track1), maxCount);
assert_less_than(maxCount, maxFrames,
'Should get the white value within ' + maxFrames + ' frames');
// Test a set of other values - far enough apart to make the test fast.
for (let signal = 2; signal <= 255; signal += 47) {
if (Math.abs(signal - 100) > 10) {
const count = await signalSettlementTime(t, v, sender, signal, track1);
maxCount = Math.max(count, maxCount);
assert_less_than(maxCount, 10,
'Should get value ' + signal + ' within ' + maxFrames + ' frames');
}
}
assert_less_than(maxCount, 10, 'Should get the right value within 10 frames');
}, 'Signal detector detects track change within reasonable time');
</script>
|
