audiocontext-playoutstats.html

Enable keyboard shortcuts

This test has a WPT meta file that expects 4 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /webaudio/the-audio-api/the-audiocontext-interface/audiocontext-playoutstats.html - WPT Dashboard Interop Dashboard

<!DOCTYPE html>

<html>

  <head>

    <title>Testing AudioContext.playoutStats attribute</title>

    <script src="/resources/testharness.js"></script>

    <script src="/resources/testharnessreport.js"></script>

  </head>

  <body>

    <script>

      function should_be_in_range(value, min, max) {

        assert_greater_than_equal(value, min);

        assert_less_than_equal(value, max);

      promise_test(async (t) => {

        let context = new AudioContext();

        assert_not_equals(context.playoutStats, null);

        // Initially, the stats should all be 0.

        let stats = context.playoutStats;

        assert_equals(stats.totalFramesDuration, 0);

        assert_equals(stats.fallbackFramesDuration, 0);

        assert_equals(stats.fallbackFramesEvents, 0);

        assert_equals(stats.minimumLatency, 0);

        assert_equals(stats.maximumLatency, 0);

        assert_equals(stats.averageLatency, 0);

        // Asynchronously wait for 1.5 seconds. We will then check that the

        // stats reflect that the context has been playing for at least 1

        // second. The extra 0.5 seconds is to avoid flakiness.

        // Note that awaiting moves us to a new task in the execution cycle,

        // which allows the stats to change.

        await new Promise((r) => step_timeout(r, 1500));

        assert_greater_than(stats.totalFramesDuration, 1000);

        should_be_in_range(

          stats.fallbackFramesDuration,

0,

          stats.totalFramesDuration

);

        assert_greater_than_equal(stats.fallbackFramesEvents, 0);

        assert_greater_than_equal(stats.minimumLatency, 0);

        assert_greater_than_equal(stats.maximumLatency, 0);

        should_be_in_range(

          stats.averageLatency,

          stats.minimumLatency,

          stats.maximumLatency

);

      }, "Test that the stats increase during playout");

      promise_test(async (t) => {

        let context = new AudioContext();

        // Wait a while so that we get stats that aren't all zeroes.

        await new Promise((r) => step_timeout(r, 1500));

        let stats = context.playoutStats;

        assert_greater_than(stats.totalFramesDuration, 1000);

        // Check that the stats from the toJSON object match the PlayoutStats

        // object.

        let json = stats.toJSON();

        assert_equals(json.totalFramesDuration, stats.totalFramesDuration);

        assert_equals(

          json.fallbackFramesDuration,

          stats.fallbackFramesDuration

);

        assert_equals(json.fallbackFramesEvents, stats.fallbackFramesEvents);

        assert_equals(json.minimumLatency, stats.minimumLatency);

        assert_equals(json.maximumLatency, stats.maximumLatency);

        assert_equals(json.averageLatency, stats.averageLatency);

      }, "Test that toJSON reflects the current stats");

      promise_test(async (t) => {

        let context = new AudioContext();

        // Wait a while so that we get stats that aren't all zeroes.

        await new Promise((r) => step_timeout(r, 1500));

        let stats = context.playoutStats;

        assert_greater_than(stats.totalFramesDuration, 1000);

        // Average latency should be between minimum and maximum.

        let beforeReset = stats.toJSON();

        should_be_in_range(

          beforeReset.averageLatency,

          beforeReset.minimumLatency,

          beforeReset.maximumLatency

);

        // After a reset, the minimum, maximum and average latencies should be

        // the same.

        stats.resetLatency();

        let afterReset = stats.toJSON();

        assert_equals(afterReset.minimumLatency, afterReset.averageLatency);

        assert_equals(afterReset.maximumLatency, afterReset.averageLatency);

      }, "Test PlayoutStats.resetLatency()");

      promise_test(async (t) => {

        // Tests that the API adheres to run to completion semantics, as

        // defined here: https://w3ctag.github.io/design-principles/#js-rtc

        let context = new AudioContext();

        // Wait a while so that we get stats that aren't all zeroes.

        await new Promise((r) => step_timeout(r, 1500));

        let stats = context.playoutStats;

        assert_greater_than(stats.totalFramesDuration, 1000);

        let beforeWait = stats.toJSON();

        // Synchronously wait 500 ms.

        const start = performance.now();

        while (performance.now() - start < 500);

        // We are still in the same execution cycle, so the stats shouldn't

        // have changed.

        assert_equals(

          stats.totalFramesDuration,

          beforeWait.totalFramesDuration

);

        assert_equals(

          stats.fallbackFramesDuration,

          beforeWait.fallbackFramesDuration

);

        assert_equals(

          stats.fallbackFramesEvents,

          beforeWait.fallbackFramesEvents

);

        assert_equals(stats.minimumLatency, beforeWait.minimumLatency);

        assert_equals(stats.maximumLatency, beforeWait.maximumLatency);

        assert_equals(stats.averageLatency, beforeWait.averageLatency);

        // Move to the next execution cycle. Since it was 500 ms since the

        // stats were last updated, they have now increased.

        await Promise.resolve();

        assert_greater_than(

          stats.totalFramesDuration,

          beforeWait.totalFramesDuration

);

      }, "Test that stats are unchanged within the same execution cycle.");

    </script>

  </body>

</html>