opus-multichannel.https.any.js

Enable keyboard shortcuts

This test has a WPT meta file that expects 2 subtest issues.
This WPT test may be referenced by the following Test IDs:
- /webcodecs/opus-multichannel.https.any.html - WPT Dashboard Interop Dashboard

// META: global=window

// META: script=/webcodecs/utils.js

// Encode `channels` channels of audio through AudioEncoder and collect all

// output chunks + the first decoderConfig emitted.

async function encode_opus(t, channels) {

  const config = {

    codec: 'opus',

    sampleRate: 48000,

    numberOfChannels: channels,

};

  const support = await AudioEncoder.isConfigSupported(config);

  assert_true(support.supported,

    `${channels}ch Opus encoding must be supported`);

  let decoder_config = null;

  let chunks = [];

  const encoder = new AudioEncoder({

    output: (chunk, metadata) => {

      if (metadata?.decoderConfig) {

        if (!decoder_config) decoder_config = metadata.decoderConfig;

      chunks.push(chunk);

},

    error: e => assert_unreached('encoder error: ' + e),

});

  encoder.configure(config);

  // One second of audio is enough to produce multiple Opus frames.

  const data = make_audio_data(0, channels, 48000, 48000);

  encoder.encode(data);

  await encoder.flush();

  encoder.close();

  data.close();

  return { decoder_config, chunks };

// Verify the OpusHead magic bytes ('O','p','u','s','H','e','a','d').

function assert_valid_opushead(description, label) {

  const bytes = new Uint8Array(description);

  assert_greater_than_equal(bytes.length, 19,

    `${label}: description must be at least 19 bytes`);

  assert_equals(bytes[0], 0x4f, `${label}: description[0] == 'O'`);

  assert_equals(bytes[1], 0x70, `${label}: description[1] == 'p'`);

  assert_equals(bytes[2], 0x75, `${label}: description[2] == 'u'`);

  assert_equals(bytes[3], 0x73, `${label}: description[3] == 's'`);

  assert_equals(bytes[4], 0x48, `${label}: description[4] == 'H'`);

  assert_equals(bytes[5], 0x65, `${label}: description[5] == 'e'`);

  assert_equals(bytes[6], 0x61, `${label}: description[6] == 'a'`);

  assert_equals(bytes[7], 0x64, `${label}: description[7] == 'd'`);

promise_test(async t => {

  const channels = 16;

  const { decoder_config, chunks } = await encode_opus(t, channels);

  assert_greater_than(chunks.length, 0, 'encoder must produce output');

  assert_not_equals(decoder_config, null,

    'encoder must emit decoderConfig in metadata');

  assert_equals(decoder_config.codec, 'opus');

  assert_equals(decoder_config.numberOfChannels, channels);

  assert_equals(decoder_config.sampleRate, 48000);

  assert_not_equals(decoder_config.description, null,

    'decoderConfig.description must be present for >2ch Opus');

  assert_valid_opushead(decoder_config.description, '16ch');

  // channel count must be in the description (byte 9, 0-indexed)

  const bytes = new Uint8Array(decoder_config.description);

  assert_equals(bytes[9], channels,

    'OpusHead channel count byte must match numberOfChannels');

}, 'Encoding 16ch Opus produces a valid OpusHead decoderConfig description.');

promise_test(async t => {

  const channels = 16;

  const { decoder_config, chunks } = await encode_opus(t, channels);

  assert_not_equals(decoder_config, null, 'need decoderConfig to test decode');

  assert_greater_than(chunks.length, 0, 'need chunks to decode');

  let decoded_frames = [];

  const decoder = new AudioDecoder({

    output: frame => { decoded_frames.push(frame); },

    error: e => assert_unreached('decoder error: ' + e),

});

  decoder.configure({

    codec: 'opus',

    sampleRate: 48000,

    numberOfChannels: channels,

    description: decoder_config.description,

});

  for (const chunk of chunks) {

    decoder.decode(chunk);

  await decoder.flush();

  decoder.close();

  assert_greater_than(decoded_frames.length, 0, 'decoder must produce output');

  for (const frame of decoded_frames) {

    assert_equals(frame.numberOfChannels, channels,

      'decoded frame must have ' + channels + ' channels');

    frame.close();

}, 'Encoding then decoding 16ch Opus produces frames with 16 channels.');

promise_test(async t => {

  const config = {

    codec: 'opus',

    sampleRate: 48000,

    numberOfChannels: 16,

    // no description

};

  // configure() queues work; the codec-specific failure surfaces asynchronously

  // through the error callback.

  const error = await new Promise(resolve => {

    const decoder = new AudioDecoder({

      output: () => {},

      error: e => resolve(e),

});

    decoder.configure(config);

});

  assert_equals(error.name, 'NotSupportedError',

    '>2ch Opus without description must fire NotSupportedError');

}, 'Configuring AudioDecoder with 16ch Opus without description must fail.');