tor-browser

audio-encoder.https.any.js (18192B)

---

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

// Merge all audio buffers into a new big one with all the data.
function join_audio_data(audio_data_array) {
 assert_greater_than_equal(audio_data_array.length, 0);
 let total_frames = 0;
 let base_buffer = audio_data_array[0];
 for (const data of audio_data_array) {
   assert_not_equals(data, null);
   assert_equals(data.sampleRate, base_buffer.sampleRate);
   assert_equals(data.numberOfChannels, base_buffer.numberOfChannels);
   assert_equals(data.format, base_buffer.format);
   total_frames += data.numberOfFrames;
 }

 assert_true(base_buffer.format == 'f32' || base_buffer.format == 'f32-planar');

 if (base_buffer.format == 'f32')
   return join_interleaved_data(audio_data_array, total_frames);

 // The format is 'FLTP'.
 return join_planar_data(audio_data_array, total_frames);
}

function join_interleaved_data(audio_data_array, total_frames) {
 let base_data =  audio_data_array[0];
 let channels = base_data.numberOfChannels;
 let total_samples = total_frames * channels;

 let result = new Float32Array(total_samples);

 let copy_dest = new Float32Array(base_data.numberOfFrames * channels);

 // Copy all the interleaved data.
 let position = 0;
 for (const data of audio_data_array) {
   let samples = data.numberOfFrames * channels;
   if (copy_dest.length < samples)
     copy_dest = new Float32Array(samples);

   data.copyTo(copy_dest, {planeIndex: 0});
   result.set(copy_dest, position);
   position += samples;
 }

 assert_equals(position, total_samples);

 return result;
}

function join_planar_data(audio_data_array, total_frames) {
 let base_frames = audio_data_array[0].numberOfFrames;
 let channels = audio_data_array[0].numberOfChannels;
 let result = new Float32Array(total_frames*channels);
 let copyDest = new Float32Array(base_frames);

 // Merge all samples and lay them out according to the FLTP memory layout.
 let position = 0;
 for (let ch = 0; ch < channels; ch++) {
   for (const data of audio_data_array) {
     data.copyTo(copyDest, { planeIndex: ch});
     result.set(copyDest, position);
     position += data.numberOfFrames;
   }
 }
 assert_equals(position, total_frames * channels);

 return result;
}

promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 1;
 let data_count = 10;
 let outputs = [];
 let init = {
   error: e => {
     assert_unreached("error: " + e);
   },
   output: chunk => {
     outputs.push(chunk);
   }
 };

 let encoder = new AudioEncoder(init);

 assert_equals(encoder.state, "unconfigured");
 let config = {
   codec: 'opus',
   sampleRate: sample_rate,
   numberOfChannels: 2,
   bitrate: 256000 //256kbit
 };

 encoder.configure(config);

 let timestamp_us = 0;
 let data_duration_s = total_duration_s / data_count;
 let data_length = data_duration_s * config.sampleRate;
 for (let i = 0; i < data_count; i++) {
   let data = make_audio_data(timestamp_us, config.numberOfChannels,
     config.sampleRate, data_length);
   encoder.encode(data);
   data.close();
   timestamp_us += data_duration_s * 1_000_000;
 }
 await encoder.flush();
 encoder.close();
 assert_greater_than_equal(outputs.length, data_count);
 assert_equals(outputs[0].timestamp, 0, "first chunk timestamp");
 let total_encoded_duration = 0
 for (chunk of outputs) {
   assert_greater_than(chunk.byteLength, 0);
   assert_greater_than_equal(timestamp_us, chunk.timestamp);
   assert_greater_than(chunk.duration, 0);
   total_encoded_duration += chunk.duration;
 }

 // The total duration might be padded with silence.
 assert_greater_than_equal(
     total_encoded_duration, total_duration_s * 1_000_000);
}, 'Simple audio encoding');

promise_test(async t => {
 let outputs = 0;
 let init = getDefaultCodecInit(t);
 let firstOutput = new Promise(resolve => {
   init.output = (chunk, metadata) => {
     outputs++;
     assert_equals(outputs, 1, 'outputs');
     encoder.reset();
     resolve();
   };
 });

 let encoder = new AudioEncoder(init);
 let config = {
   codec: 'opus',
   sampleRate: 48000,
   numberOfChannels: 2,
   bitrate: 256000  // 256kbit
 };
 encoder.configure(config);

 let frame_count = 1024;
 let frame1 = make_audio_data(
     0, config.numberOfChannels, config.sampleRate, frame_count);
 let frame2 = make_audio_data(
     frame_count / config.sampleRate, config.numberOfChannels,
     config.sampleRate, frame_count);
 t.add_cleanup(() => {
   frame1.close();
   frame2.close();
 });

 encoder.encode(frame1);
 encoder.encode(frame2);
 const flushDone = encoder.flush();

 // Wait for the first output, then reset.
 await firstOutput;

 // Flush should have been synchronously rejected.
 await promise_rejects_dom(t, 'AbortError', flushDone);

 assert_equals(outputs, 1, 'outputs');
}, 'Test reset during flush');

promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 1;
 let data_count = 10;
 let outputs = [];
 let init = {
   error: e => {
     assert_unreached('error: ' + e);
   },
   output: chunk => {
     outputs.push(chunk);
   }
 };

 let encoder = new AudioEncoder(init);

 assert_equals(encoder.state, 'unconfigured');
 let config = {
   codec: 'opus',
   sampleRate: sample_rate,
   numberOfChannels: 2,
   bitrate: 256000  // 256kbit
 };

 encoder.configure(config);

 let timestamp_us = -10000;
 let data = make_audio_data(
     timestamp_us, config.numberOfChannels, config.sampleRate, 10000);
 encoder.encode(data);
 data.close();
 await encoder.flush();
 encoder.close();
 assert_greater_than_equal(outputs.length, 1);
 assert_equals(outputs[0].timestamp, -10000, 'first chunk timestamp');
 for (chunk of outputs) {
   assert_greater_than(chunk.byteLength, 0);
   assert_greater_than_equal(chunk.timestamp, timestamp_us);
 }
}, 'Encode audio with negative timestamp');

async function checkEncodingError(t, config, good_data, bad_data) {
 let support = await AudioEncoder.isConfigSupported(config);
 assert_true(support.supported)
 config = support.config;

 const callbacks = {};
 let errors = 0;
 let gotError = new Promise(resolve => callbacks.error = e => {
   errors++;
   resolve(e);
 });

 let outputs = 0;
 callbacks.output = chunk => {
   outputs++;
 };

 let encoder = new AudioEncoder(callbacks);
 encoder.configure(config);
 for (let data of good_data) {
   encoder.encode(data);
   data.close();
 }
 await encoder.flush();

 let txt_config = "sampleRate: " + config.sampleRate
                + " numberOfChannels: " + config.numberOfChannels;
 assert_equals(errors, 0, txt_config);
 assert_greater_than(outputs, 0);
 outputs = 0;

 encoder.encode(bad_data);
 await promise_rejects_dom(t, 'EncodingError', encoder.flush().catch((e) => {
   assert_equals(errors, 1);
   throw e;
 }));

 assert_equals(outputs, 0);
 let e = await gotError;
 assert_true(e instanceof DOMException);
 assert_equals(e.name, 'EncodingError');
 assert_equals(encoder.state, 'closed', 'state');
}

function channelNumberVariationTests() {
 let sample_rate = 48000;
 for (let channels = 1; channels <= 2; channels++) {
   let config = {
     codec: 'opus',
     sampleRate: sample_rate,
     numberOfChannels: channels,
     bitrate: 128000
   };

   let ts = 0;
   let length = sample_rate / 10;
   let data1 = make_audio_data(ts, channels, sample_rate, length);

   ts += Math.floor(data1.duration / 1000000);
   let data2 = make_audio_data(ts, channels, sample_rate, length);
   ts += Math.floor(data2.duration / 1000000);

   let bad_data = make_audio_data(ts, channels + 1, sample_rate, length);
   promise_test(
       async t => checkEncodingError(t, config, [data1, data2], bad_data),
       'Channel number variation: ' + channels);
 }
}
channelNumberVariationTests();

function sampleRateVariationTests() {
 let channels = 1
 for (let sample_rate = 3000; sample_rate < 96000; sample_rate += 10000) {
   let config = {
     codec: 'opus',
     sampleRate: sample_rate,
     numberOfChannels: channels,
     bitrate: 128000
   };

   let ts = 0;
   let length = sample_rate / 10;
   let data1 = make_audio_data(ts, channels, sample_rate, length);

   ts += Math.floor(data1.duration / 1000000);
   let data2 = make_audio_data(ts, channels, sample_rate, length);
   ts += Math.floor(data2.duration / 1000000);

   let bad_data = make_audio_data(ts, channels, sample_rate + 333, length);
   promise_test(
       async t => checkEncodingError(t, config, [data1, data2], bad_data),
       'Sample rate variation: ' + sample_rate);
 }
}
sampleRateVariationTests();

promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 1;
 let data_count = 10;
 let input_data = [];
 let output_data = [];

 let decoder_init = {
   error: t.unreached_func("Decode error"),
   output: data => {
     output_data.push(data);
   }
 };
 let decoder = new AudioDecoder(decoder_init);

 let encoder_init = {
   error: t.unreached_func("Encoder error"),
   output: (chunk, metadata) => {
     let config = metadata.decoderConfig;
     if (config)
       decoder.configure(config);
     decoder.decode(chunk);
   }
 };
 let encoder = new AudioEncoder(encoder_init);

 let config = {
   codec: 'opus',
   sampleRate: sample_rate,
   numberOfChannels: 2,
   bitrate: 256000, //256kbit
 };
 encoder.configure(config);

 let timestamp_us = 0;
 const data_duration_s = total_duration_s / data_count;
 const data_length = data_duration_s * config.sampleRate;
 for (let i = 0; i < data_count; i++) {
   let data = make_audio_data(timestamp_us, config.numberOfChannels,
     config.sampleRate, data_length);
   input_data.push(data);
   encoder.encode(data);
   timestamp_us += data_duration_s * 1_000_000;
 }
 await encoder.flush();
 encoder.close();
 await decoder.flush();
 decoder.close();


 let total_input = join_audio_data(input_data);
 let frames_per_plane = total_input.length / config.numberOfChannels;

 let total_output = join_audio_data(output_data);

 let base_input = input_data[0];
 let base_output = output_data[0];

 // TODO: Convert formats to simplify conversions, once
 // https://github.com/w3c/webcodecs/issues/232 is resolved.
 assert_equals(base_input.format, "f32-planar");
 assert_equals(base_output.format, "f32");

 assert_equals(base_output.numberOfChannels, config.numberOfChannels);
 assert_equals(base_output.sampleRate, sample_rate);

 // Output can be slightly longer that the input due to padding
 assert_greater_than_equal(total_output.length, total_input.length);

 // Compare waveform before and after encoding
 for (let channel = 0; channel < base_input.numberOfChannels; channel++) {

   let plane_start = channel * frames_per_plane;
   let input_plane = total_input.slice(
       plane_start, plane_start + frames_per_plane);

   for (let i = 0; i < base_input.numberOfFrames; i += 10) {
     // Instead of de-interleaving the data, directly look into |total_output|
     // for the sample we are interested in.
     let ouput_index = i * base_input.numberOfChannels + channel;

     // Checking only every 10th sample to save test time in slow
     // configurations like MSAN etc.
     assert_approx_equals(
         input_plane[i], total_output[ouput_index], 0.5,
         'Difference between input and output is too large.' +
             ' index: ' + i + ' channel: ' + channel +
             ' input: ' + input_plane[i] +
             ' output: ' + total_output[ouput_index]);
   }
 }

}, 'Encoding and decoding');

promise_test(async t => {
 let output_count = 0;
 let encoder_config = {
   codec: 'opus',
   sampleRate: 24000,
   numberOfChannels: 1,
   bitrate: 96000
 };
 let decoder_config = null;

 let init = {
   error: t.unreached_func("Encoder error"),
   output: (chunk, metadata) => {
     let config = metadata.decoderConfig;
     // Only the first invocation of the output callback is supposed to have
     // a |config| in it.
     output_count++;
     if (output_count == 1) {
       assert_equals(typeof config, "object");
       decoder_config = config;
     } else {
       assert_equals(config, undefined);
     }
   }
 };

 let encoder = new AudioEncoder(init);
 encoder.configure(encoder_config);

 let large_data = make_audio_data(0, encoder_config.numberOfChannels,
   encoder_config.sampleRate, encoder_config.sampleRate);
 encoder.encode(large_data);
 await encoder.flush();

 // Large data produced more than one output, and we've got decoder_config
 assert_greater_than(output_count, 1);
 assert_not_equals(decoder_config, null);
 assert_equals(decoder_config.codec, encoder_config.codec);
 assert_equals(decoder_config.sampleRate, encoder_config.sampleRate);
 assert_equals(decoder_config.numberOfChannels, encoder_config.numberOfChannels);

 // Check that description start with 'Opus'
 let extra_data = new Uint8Array(decoder_config.description);
 assert_equals(extra_data[0], 0x4f);
 assert_equals(extra_data[1], 0x70);
 assert_equals(extra_data[2], 0x75);
 assert_equals(extra_data[3], 0x73);

 decoder_config = null;
 output_count = 0;
 encoder_config.bitrate = 256000;
 encoder.configure(encoder_config);
 encoder.encode(large_data);
 await encoder.flush();

 // After reconfiguring encoder should produce decoder config again
 assert_greater_than(output_count, 1);
 assert_not_equals(decoder_config, null);
 assert_not_equals(decoder_config.description, null);
 encoder.close();
}, "Emit decoder config and extra data.");

promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 1;
 let data_count = 100;
 let init = getDefaultCodecInit(t);
 init.output = (chunk, metadata) => {}

 let encoder = new AudioEncoder(init);

 // No encodes yet.
 assert_equals(encoder.encodeQueueSize, 0);

 let config = {
   codec: 'opus',
   sampleRate: sample_rate,
   numberOfChannels: 2,
   bitrate: 256000 //256kbit
 };
 encoder.configure(config);

 // Still no encodes.
 assert_equals(encoder.encodeQueueSize, 0);

 let datas = [];
 let timestamp_us = 0;
 let data_duration_s = total_duration_s / data_count;
 let data_length = data_duration_s * config.sampleRate;
 for (let i = 0; i < data_count; i++) {
   let data = make_audio_data(timestamp_us, config.numberOfChannels,
     config.sampleRate, data_length);
   datas.push(data);
   timestamp_us += data_duration_s * 1_000_000;
 }

 let lastDequeueSize = Infinity;
 encoder.ondequeue = () => {
   assert_greater_than(lastDequeueSize, 0, "Dequeue event after queue empty");
   assert_greater_than(lastDequeueSize, encoder.encodeQueueSize,
                       "Dequeue event without decreased queue size");
   lastDequeueSize = encoder.encodeQueueSize;
 };

 for (let data of datas)
   encoder.encode(data);

 assert_greater_than_equal(encoder.encodeQueueSize, 0);
 assert_less_than_equal(encoder.encodeQueueSize, data_count);

 await encoder.flush();
 // We can guarantee that all encodes are processed after a flush.
 assert_equals(encoder.encodeQueueSize, 0);
 // Last dequeue event should fire when the queue is empty.
 assert_equals(lastDequeueSize, 0);

 // Reset this to Infinity to track the decline of queue size for this next
 // batch of encodes.
 lastDequeueSize = Infinity;

 for (let data of datas) {
   encoder.encode(data);
   data.close();
 }

 assert_greater_than_equal(encoder.encodeQueueSize, 0);
 encoder.reset();
 assert_equals(encoder.encodeQueueSize, 0);
}, 'encodeQueueSize test');

const testOpusEncoderConfigs = [
 {
   comment: 'Empty Opus config',
   opus: {},
 },
 {
   comment: 'Opus with frameDuration',
   opus: {frameDuration: 2500},
 },
 {
   comment: 'Opus with complexity',
   opus: {complexity: 10},
 },
 {
   comment: 'Opus with useinbandfec',
   opus: {
     packetlossperc: 15,
     useinbandfec: true,
   },
 },
 {
   comment: 'Opus with usedtx',
   opus: {usedtx: true},
 },
 {
   comment: 'Opus mixed parameters',
   opus: {
     frameDuration: 40000,
     complexity: 0,
     packetlossperc: 10,
     useinbandfec: true,
     usedtx: true,
   },
 }
];

testOpusEncoderConfigs.forEach(entry => {
 promise_test(async t => {
   let sample_rate = 48000;
   let total_duration_s = 0.5;
   let data_count = 10;
   let outputs = [];
   let init = {
     error: e => {
       assert_unreached('error: ' + e);
     },
     output: chunk => {
       outputs.push(chunk);
     }
   };

   let encoder = new AudioEncoder(init);

   assert_equals(encoder.state, 'unconfigured');
   let config = {
     codec: 'opus',
     sampleRate: sample_rate,
     numberOfChannels: 2,
     bitrate: 256000,  // 256kbit
     opus: entry.opus,
   };

   encoder.configure(config);

   let timestamp_us = 0;
   let data_duration_s = total_duration_s / data_count;
   let data_length = data_duration_s * config.sampleRate;
   for (let i = 0; i < data_count; i++) {
     let data = make_audio_data(
         timestamp_us, config.numberOfChannels, config.sampleRate,
         data_length);
     encoder.encode(data);
     data.close();
     timestamp_us += data_duration_s * 1_000_000;
   }

   // Encoders might output an extra buffer of silent padding.
   let padding_us = data_duration_s * 1_000_000;

   await encoder.flush();
   encoder.close();
   assert_greater_than_equal(outputs.length, data_count);
   assert_equals(outputs[0].timestamp, 0, 'first chunk timestamp');
   let total_encoded_duration = 0
   for (chunk of outputs) {
     assert_greater_than(chunk.byteLength, 0, 'chunk byteLength');
     assert_greater_than_equal(
         timestamp_us + padding_us, chunk.timestamp, 'chunk timestamp');
     assert_greater_than(chunk.duration, 0, 'chunk duration');
     total_encoded_duration += chunk.duration;
   }

   // The total duration might be padded with silence.
   assert_greater_than_equal(
       total_encoded_duration, total_duration_s * 1_000_000);
 }, 'Test encoding Opus with additional parameters: ' + entry.comment);
});