Skip to content

GitLab

T
tangled
Commit 6b76953a authored by Raymond Toy's avatar Raymond Toy Committed by Commit Bot
Browse files
Options

Make ChannelMerger active processing test less flaky 

Replace the offline audio context with a realtime context and an AudioWorklet.
Previously, when the source stopped, the channel count change would sometimes
get delayed until rendering is done, which is too late for the test.  I believe
this is because the main thread was previously too busy to process the messages
to disable outputs and change the channel count.

Using a realtime context makes the main thread less busy because the messages
aren't posted as fast as possible, allowing time for them to be handled. I think
this is still flaky, but much less so than before.

Bug: 974258
Test: the-channelmergernode-interface/active-processing.https.html
Change-Id: Id584ebfa5f54ad6870819f5242aafed5f4fc80d1
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1663186Reviewed-by: default avatarHongchan Choi <hongchan@chromium.org>
Commit-Queue: Raymond Toy <rtoy@chromium.org>
Cr-Commit-Position: refs/heads/master@{#677078}
parent b2720ad1
Hide whitespace changes
Inline Side-by-side
Showing with 124 additions and 85 deletions
third_party/blink/web_tests/external/wpt/webaudio/the-audio-api/the-audioworklet-interface/processors/active-processing.js 0 → 100644
View file @ 6b76953a
/**
* @class ActiveProcessingTester
* @extends AudioWorkletProcessor
*
* This processor class sends a message to its AudioWorkletNodew whenever the
* number of channels on the input changes. The message includes the actual
* number of channels, the context time at which this occurred, and whether
* we're done processing or not.
*/
class ActiveProcessingTester extends AudioWorkletProcessor {
constructor(options) {
super(options);
this._lastChannelCount = 0;
// See if user specified a value for test duration.
if (options.hasOwnProperty('processorOptions') &&
options.processorOptions.hasOwnProperty('testDuration')) {
this._testDuration = options.processorOptions.testDuration;
} else {
this._testDuration = 5;
}
// Time at which we'll signal we're done, based on the requested
// |testDuration|
this._endTime = currentTime + this._testDuration;
}
process(inputs, outputs) {
const input = inputs[0];
const output = outputs[0];
const inputChannelCount = input.length;
const isFinished = currentTime > this._endTime;
// Send a message if we're done or the count changed.
if (isFinished || (inputChannelCount != this._lastChannelCount)) {
this.port.postMessage({
channelCount: inputChannelCount,
finished: isFinished,
time: currentTime
});
this._lastChannelCount = inputChannelCount;
}
// Just copy the input to the output for no particular reason.
for (let channel = 0; channel < input.length; ++channel) {
output[channel].set(input[channel]);
}
// When we're finished, this method no longer needs to be called.
return !isFinished;
}
}
registerProcessor('active-processing-tester', ActiveProcessingTester);
third_party/blink/web_tests/external/wpt/webaudio/the-audio-api/the-channelmergernode-interface/active-processing.https.html
View file @ 6b76953a
......@@ -6,101 +6,86 @@
</title>
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/webaudio/resources/audit-util.js"></script>
<script src="/webaudio/resources/audit.js"></script>
</head>
<body>
<script id="layout-test-code">
let audit = Audit.createTaskRunner();
// The sample rate MUST be a power of two to eliminate round-off when
// computing render boundaries but is otherwise arbitrary. And we only new
// a few blocks for rendering to see if things are working.
let sampleRate = 8192;
let renderLength = 10 * RENDER_QUANTUM_FRAMES;
// Number of inputs for the ChannelMergerNode. Pretty arbitrary, but
// should not be 1.
let numberOfInputs = 7;
// How many frames the source should run. Arbitrary but should be more
// than a render quantum.
let sourceDurationFrames = 131;
// Frame at which to connect the source to the merger
let connectFrame = 2 * RENDER_QUANTUM_FRAMES;
// AudioProcessor that counts the number of channels on its single input.
// AudioProcessor that sends a message to its AudioWorkletNode whenver the
// number of channels on its input changes.
let filePath =
'../the-audioworklet-interface/processors/input-count-processor.js';
audit.define(
{
label: 'Test',
description: 'Active processing for ChannelMergerNode'
},
async (task, should) => {
const context = new OfflineAudioContext({
numberOfChannels: numberOfInputs,
length: renderLength,
sampleRate: sampleRate
'../the-audioworklet-interface/processors/active-processing.js';
const audit = Audit.createTaskRunner();
let context;
audit.define('initialize', (task, should) => {
// Create context and load the module
context = new AudioContext();
should(
context.audioWorklet.addModule(filePath),
'AudioWorklet module loading')
.beResolved()
.then(() => task.done());
});
audit.define('test', (task, should) => {
const src = new OscillatorNode(context);
// Number of inputs for the ChannelMergerNode. Pretty arbitrary, but
// should not be 1.
const numberOfInputs = 7;
const merger =
new ChannelMergerNode(context, {numberOfInputs: numberOfInputs});
const testerNode =
new AudioWorkletNode(context, 'active-processing-tester', {
// Use as short a duration as possible to keep the test from
// taking too much time.
processorOptions: {testDuration: .5},
});
// Don't mix the inputs to the destination!
context.destination.channelInterpretation = 'discrete';
await context.audioWorklet.addModule(filePath);
let src = new ConstantSourceNode(context);
let merger = new ChannelMergerNode(
context, {numberOfInputs: numberOfInputs});
let counter = new AudioWorkletNode(context, 'counter');
// Just to print a message that we created the graph with a
// convolver in it.
should(
() => {
merger.connect(counter).connect(context.destination);
},
`Construction of graph with ChannelMergerNode with ${
merger.numberOfInputs} inputs`)
.notThrow()
// Connect the source now and start it and let it run for
// |sourceDurationFrames| frames.
context.suspend(connectFrame / context.sampleRate)
.then(() => {
src.connect(merger, 0, 0);
src.start();
src.stop(
context.currentTime +
sourceDurationFrames / context.sampleRate);
})
.then(() => context.resume());
const renderedBuffer = await context.startRendering();
// The expected output is something like:
//
// 1, 1, 1,..., 7, 7, 7.,,,, 1, 1, 1
//
// When the merger has no inputs, it's not actively processing
// so it must output mono silence. After connecting a source,
// the number of channels of the output should be the same as
// the number of inputs to the merger. Finally, when the
// source stops, the merger is not actively processing anymore
// and should output mono silence again. For this test, we
// don't care too much how many different values there are.
// There just has to be at least one of each value, in the
// order given.
const output = renderedBuffer.getChannelData(0);
should(output, 'Number of output channels').containValues([
1, numberOfInputs, 1
]);
// Expected number of output channels from the merger node. We should
// start with the number of inputs, because the source (oscillator) is
// actively processing. When the source stops, the number of channels
// should change to 1.
const expectedValues = [numberOfInputs, 1];
let index = 0;
testerNode.port.onmessage = event => {
let count = event.data.channelCount;
let finished = event.data.finished;
// If we're finished, end testing.
if (finished) {
// Verify that we got the expected number of changes.
should(index, 'Number of distinct values')
.beEqualTo(expectedValues.length);
task.done();
});
return;
}
if (index < expectedValues.length) {
// Verify that the number of channels matches the expected number of
// channels.
should(count, `Test ${index}: Number of convolver output channels`)
.beEqualTo(expectedValues[index]);
}
++index;
};
// Create the graph and go
src.connect(merger).connect(testerNode).connect(context.destination);
src.start();
// Stop the source after a short time so we can test that the channel
// merger changes to not actively processing and thus produces a single
// channel of silence.
src.stop(context.currentTime + .1);
});
audit.run();
</script>
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment