| <!doctype html> |
| <meta charset=utf-8> |
| <meta name="timeout" content="long"> |
| <script src="/resources/testharness.js"></script> |
| <script src="/resources/testharnessreport.js"></script> |
| <script> |
| 'use strict'; |
| |
| async function getFrameStatsUntil(track, condition) { |
| while (true) { |
| const stats = await track.getFrameStats(); |
| if (condition(stats)) { |
| return stats; |
| } |
| } |
| } |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({video:true}); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| const firstStats = |
| await getFrameStatsUntil(track, stats => stats.totalFrames > 0); |
| await getFrameStatsUntil(track, |
| stats => stats.totalFrames > firstStats.totalFrames); |
| }, `totalFrames increases over time`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({video:true}); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // `deliveredFrames` increments for each deliverable frame, even if the |
| // `track` does not have any sink. |
| const firstStats = await getFrameStatsUntil( |
| track, stats => stats.deliveredFrames > 0); |
| await getFrameStatsUntil( |
| track, stats => stats.deliveredFrames > firstStats.deliveredFrames); |
| }, `deliveredFrames increases, even without sinks`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ |
| video:{frameRate:{ideal:20}} |
| }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Assert test prerequisite is met: frames will be discarded if the track is |
| // opened with a higher frame rate than we apply after it is opened. |
| assert_greater_than(track.getSettings().frameRate, 10); |
| await track.applyConstraints({frameRate:{ideal:10}}); |
| |
| await getFrameStatsUntil(track, stats => stats.discardedFrames > 0); |
| }, `discardedFrames increases when frameRate decimation is happening`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ |
| video:{frameRate:{ideal:20}} |
| }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Assert test prerequisite is met: frames will be discarded if the track is |
| // opened with a higher frame rate than we apply after it is opened. |
| assert_greater_than(track.getSettings().frameRate, 10); |
| await track.applyConstraints({frameRate:{ideal:10}}); |
| |
| // Wait until we have both delivered and discarded frames. |
| const stats = await getFrameStatsUntil(track, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| |
| // This test assumes that no frames are dropped, otherwise `totalFrames` can |
| // be greater than the sum of `deliveredFrames` and `discardedFrames`. |
| assert_equals(stats.totalFrames, |
| stats.deliveredFrames + stats.discardedFrames); |
| }, `totalFrames is the sum of deliveredFrames and discardedFrames`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ |
| video:{frameRate:{ideal:20}} |
| }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Assert test prerequisite is met: frames will be discarded if the track is |
| // opened with a higher frame rate than we apply after it is opened. |
| assert_greater_than(track.getSettings().frameRate, 10); |
| await track.applyConstraints({frameRate:{ideal:10}}); |
| |
| // Wait for media to flow before disabling the `track`. |
| const initialStats = await getFrameStatsUntil(track, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0 && |
| stats.totalFrames > 10); |
| track.enabled = false; |
| // Upon disabling, the counters are not reset. |
| const disabledSnapshot = await track.getFrameStats(); |
| assert_greater_than_equal(disabledSnapshot.deliveredFrames, |
| initialStats.deliveredFrames); |
| assert_greater_than_equal(disabledSnapshot.discardedFrames, |
| initialStats.discardedFrames); |
| assert_greater_than_equal(disabledSnapshot.totalFrames, |
| initialStats.totalFrames); |
| |
| // Wait enough time that frames should have been produced. |
| await new Promise(r => t.step_timeout(r, 500)); |
| |
| // Frame metrics should be frozen, but because `enabled = false` does not |
| // return a promise, we allow some lee-way in case a frame was still in flight |
| // during the disabling. |
| const stats = await track.getFrameStats(); |
| assert_approx_equals( |
| stats.deliveredFrames, disabledSnapshot.deliveredFrames, 1); |
| assert_approx_equals( |
| stats.discardedFrames, disabledSnapshot.discardedFrames, 1); |
| assert_approx_equals(stats.totalFrames, disabledSnapshot.totalFrames, 1); |
| }, `Stats are frozen while disabled`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ |
| video:{frameRate:{ideal:20}} |
| }); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| // Assert test prerequisite is met: frames will be discarded if the track is |
| // opened with a higher frame rate than we apply after it is opened. |
| assert_greater_than(track.getSettings().frameRate, 10); |
| await track.applyConstraints({frameRate:{ideal:10}}); |
| |
| // Wait for media to flow before disabling the `track`. |
| const initialStats = await getFrameStatsUntil(track, stats => |
| stats.deliveredFrames > 10 && stats.discardedFrames > 10); |
| track.enabled = false; |
| |
| // Re-enable the track. The stats counters should be greater than or equal to |
| // what they were previously. |
| track.enabled = true; |
| const stats = await track.getFrameStats(); |
| assert_greater_than_equal(stats.deliveredFrames, |
| initialStats.deliveredFrames); |
| assert_greater_than_equal(stats.discardedFrames, |
| initialStats.discardedFrames); |
| assert_greater_than_equal(stats.totalFrames, |
| initialStats.totalFrames); |
| }, `Disabling and re-enabling does not reset the counters`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ |
| video:{frameRate:{ideal:20}} |
| }); |
| const [originalTrack] = stream.getTracks(); |
| t.add_cleanup(() => originalTrack.stop()); |
| |
| // Assert test prerequisite is met: frames will be discarded if the track is |
| // opened with a higher frame rate than we apply after it is opened. |
| assert_greater_than(originalTrack.getSettings().frameRate, 10); |
| await originalTrack.applyConstraints({frameRate:{ideal:10}}); |
| |
| // Wait for media to flow before disabling the `track`. |
| await getFrameStatsUntil(originalTrack, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| originalTrack.enabled = false; |
| const originalTrackInitialStats = await originalTrack.getFrameStats(); |
| |
| // Clone the track, its counters should be zero initially. |
| // This is not racy because the cloned track is also disabled. |
| const clonedTrack = originalTrack.clone(); |
| t.add_cleanup(() => clonedTrack.stop()); |
| const clonedTrackStats = await clonedTrack.getFrameStats(); |
| assert_equals(clonedTrackStats.deliveredFrames, 0); |
| assert_equals(clonedTrackStats.discardedFrames, 0); |
| assert_equals(clonedTrackStats.totalFrames, 0); |
| |
| // Enabled the cloned track and wait for media to flow. |
| clonedTrack.enabled = true; |
| await getFrameStatsUntil(clonedTrack, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| |
| // This does not affect the original track's stats, which are still frozen due |
| // to the original track being disabled. |
| const originalTrackSecondStats = await originalTrack.getFrameStats(); |
| assert_equals(originalTrackSecondStats.deliveredFrames, |
| originalTrackInitialStats.deliveredFrames); |
| assert_equals(originalTrackSecondStats.discardedFrames, |
| originalTrackInitialStats.discardedFrames); |
| assert_equals(originalTrackSecondStats.totalFrames, |
| originalTrackInitialStats.totalFrames); |
| }, `New stats baselines when a track is cloned from a disabled track`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ |
| video:{frameRate:{ideal:20}} |
| }); |
| const [originalTrack] = stream.getTracks(); |
| t.add_cleanup(() => originalTrack.stop()); |
| |
| // Assert test prerequisite is met: frames will be discarded if the track is |
| // opened with a higher frame rate than we apply after it is opened. |
| assert_greater_than(originalTrack.getSettings().frameRate, 10); |
| await originalTrack.applyConstraints({frameRate:{ideal:10}}); |
| |
| // Wait for media to flow. |
| await getFrameStatsUntil(originalTrack, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| |
| // Clone the track. While its counters should initially be zero, it would be |
| // racy to assert that they are exactly zero because media is flowing. |
| const clonedTrack = originalTrack.clone(); |
| t.add_cleanup(() => clonedTrack.stop()); |
| |
| // Ensure that as media continues to flow, the cloned track will necessarily |
| // have less frames than the original track on all accounts since its counters |
| // will have started from zero. |
| const clonedTrackStats = await getFrameStatsUntil(clonedTrack, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| const originalTrackStats = await originalTrack.getFrameStats(); |
| assert_less_than(clonedTrackStats.deliveredFrames, |
| originalTrackStats.deliveredFrames); |
| assert_less_than(clonedTrackStats.discardedFrames, |
| originalTrackStats.discardedFrames); |
| assert_less_than(clonedTrackStats.totalFrames, |
| originalTrackStats.totalFrames); |
| }, `New stats baselines when a track is cloned from an enabled track`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({ |
| video:{frameRate:{ideal:20}} |
| }); |
| const [originalTrack] = stream.getTracks(); |
| t.add_cleanup(() => originalTrack.stop()); |
| |
| // Assert test prerequisite is met: frames will be discarded if the track is |
| // opened with a higher frame rate than we apply after it is opened. |
| assert_greater_than(originalTrack.getSettings().frameRate, 10); |
| await originalTrack.applyConstraints({frameRate:{ideal:10}}); |
| |
| // Wait for media to flow. |
| await getFrameStatsUntil(originalTrack, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| |
| // Clone and wait for media to flow. |
| const cloneA = originalTrack.clone(); |
| t.add_cleanup(() => cloneA.stop()); |
| await getFrameStatsUntil(cloneA, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| |
| // Clone the clone and wait for media to flow. |
| const cloneB = cloneA.clone(); |
| t.add_cleanup(() => cloneB.stop()); |
| await getFrameStatsUntil(cloneB, stats => |
| stats.deliveredFrames > 0 && stats.discardedFrames > 0); |
| |
| // Because every clone reset its counters and every waits for media before |
| // cloning, this must be true: originalStats > cloneAStats > cloneBStats. |
| const originalStats = await originalTrack.getFrameStats(); |
| const cloneAStats = await cloneA.getFrameStats(); |
| const cloneBStats = await cloneB.getFrameStats(); |
| assert_greater_than(originalStats.totalFrames, cloneAStats.totalFrames); |
| assert_greater_than(cloneAStats.totalFrames, cloneBStats.totalFrames); |
| }, `New stats baselines for the clone of a clone`); |
| |
| promise_test(async t => { |
| const stream = await navigator.mediaDevices.getUserMedia({audio:true}); |
| const [track] = stream.getTracks(); |
| t.add_cleanup(() => track.stop()); |
| |
| try { |
| await track.getFrameStats(); |
| assert_not_reached(); |
| } catch (e) { |
| assert_equals(e.name, 'NotSupportedError'); |
| } |
| }, `getFrameStats throws on audio tracks`); |
| </script> |
