tor-browser

audio-encoder-codec-specific.https.any.js (10305B)

---

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

function make_silent_audio_data(timestamp, channels, sampleRate, frames) {
 let data = new Float32Array(frames*channels);

 return new AudioData({
   timestamp: timestamp,
   data: data,
   numberOfChannels: channels,
   numberOfFrames: frames,
   sampleRate: sampleRate,
   format: "f32-planar",
 });
}

// The Opus DTX flag (discontinuous transmission) reduces the encoding bitrate
// for silence. This test ensures the DTX flag is working properly by encoding
// almost 10s of silence and comparing the bitrate with and without the flag.
promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 10;
 let data_count = 100;
 let normal_outputs = [];
 let dtx_outputs = [];

 let normal_encoder = new AudioEncoder({
   error: e => {
     assert_unreached('error: ' + e);
   },
   output: chunk => {
     normal_outputs.push(chunk);
   }
 });

 let dtx_encoder = new AudioEncoder({
   error: e => {
     assert_unreached('error: ' + e);
   },
   output: chunk => {
     dtx_outputs.push(chunk);
   }
 });

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

 let normal_config = {...config, opus: {usedtx: false}};
 let dtx_config = {...config, opus: {usedtx: true}};

 let normal_config_support = await AudioEncoder.isConfigSupported(normal_config);
 assert_implements_optional(normal_config_support.supported, "Opus not supported");

 let dtx_config_support = await AudioEncoder.isConfigSupported(dtx_config);
 assert_implements_optional(dtx_config_support.supported, "Opus DTX not supported");

 // Configure one encoder with and one without the DTX flag
 normal_encoder.configure(normal_config);
 dtx_encoder.configure(dtx_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;

   if (i == 0 || i == (data_count - 1)) {
     // Send real data for the first and last 100ms.
     data = make_audio_data(
         timestamp_us, config.numberOfChannels, config.sampleRate,
         data_length);

   } else {
     // Send silence for the rest of the 10s.
     data = make_silent_audio_data(
         timestamp_us, config.numberOfChannels, config.sampleRate,
         data_length);
   }

   normal_encoder.encode(data);
   dtx_encoder.encode(data);
   data.close();

   timestamp_us += data_duration_s * 1_000_000;
 }

 await Promise.all([normal_encoder.flush(), dtx_encoder.flush()])

 normal_encoder.close();
 dtx_encoder.close();

 // We expect a significant reduction in the number of packets, over ~10s of silence.
 assert_less_than(dtx_outputs.length, (normal_outputs.length / 2));
}, 'Test the Opus DTX flag works.');


// The Opus bitrateMode enum chooses whether we use a constant or variable bitrate.
// This test ensures that VBR/CBR is respected properly by encoding almost 10s of
// silence and comparing the size of the encoded variable or constant bitrates.
promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 10;
 let data_count = 100;
 let vbr_outputs = [];
 let cbr_outputs = [];

 let cbr_encoder = new AudioEncoder({
   error: e => {
     assert_unreached('error: ' + e);
   },
   output: chunk => {
     cbr_outputs.push(chunk);
   }
 });

 let vbr_encoder = new AudioEncoder({
   error: e => {
     assert_unreached('error: ' + e);
   },
   output: chunk => {
     vbr_outputs.push(chunk);
   }
 });

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

 let cbr_config = { ...config, bitrateMode: "constant" };
 let vbr_config = { ...config, bitrateMode: "variable" };

 let cbr_config_support = await AudioEncoder.isConfigSupported(cbr_config);
 assert_implements_optional(cbr_config_support.supported, "Opus CBR not supported");

 let vbr_config_support = await AudioEncoder.isConfigSupported(vbr_config);
 assert_implements_optional(vbr_config_support.supported, "Opus VBR not supported");

 // Configure one encoder with VBR and one CBR.
 cbr_encoder.configure(cbr_config);
 vbr_encoder.configure(vbr_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;

   if (i == 0 || i == (data_count - 1)) {
     // Send real data for the first and last 100ms.
     data = make_audio_data(
       timestamp_us, config.numberOfChannels, config.sampleRate,
       data_length);

   } else {
     // Send silence for the rest of the 10s.
     data = make_silent_audio_data(
       timestamp_us, config.numberOfChannels, config.sampleRate,
       data_length);
   }

   vbr_encoder.encode(data);
   cbr_encoder.encode(data);
   data.close();

   timestamp_us += data_duration_s * 1_000_000;
 }

 await Promise.all([cbr_encoder.flush(), vbr_encoder.flush()])

 cbr_encoder.close();
 vbr_encoder.close();

 let vbr_total_bytes = 0;
 vbr_outputs.forEach(chunk => vbr_total_bytes += chunk.byteLength)

 let cbr_total_bytes = 0;
 cbr_outputs.forEach(chunk => cbr_total_bytes += chunk.byteLength)

 // We expect a significant reduction in the size of the packets, over ~10s of silence.
 assert_less_than(vbr_total_bytes, (cbr_total_bytes / 2));
}, 'Test the Opus bitrateMode flag works.');

// Opus can handle configs with a frameDuration that is any multiple of 2.5ms,
// up to 120ms. This test ensures that we can handle multiples and encoders
// return encoded packets with the correct frameDuration.
promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 10;
 let data_count = 100;

 let valid_frame_durations = [7500, 30000, 120000];
 for(const duration of valid_frame_durations) {
   let outputs = [];
   // We use an AudioDecoder to verify that the EncodedAudioChunks from
   // encoder.encode() can be decoded.
   let decoder = new AudioDecoder({
     error: e => {
       assert_unreached(`Duration ${duration} received this error: ` + e);
     },
     output: chunk => {
       chunk.close();
     }
   });
   decoder.configure({
     codec: "opus",
     numberOfChannels: 2,
     sampleRate: sample_rate
   });

   let encoder = new AudioEncoder({
     error: e => {
       assert_unreached(`Duration ${duration} received this error: ` + e);
     },
     output: chunk => {
       outputs.push(chunk);
       decoder.decode(chunk);
     }
   });
   let config = {
     codec: 'opus',
     sampleRate: sample_rate,
     numberOfChannels: 2,
     bitrate: 256000,  // 256kbit
     bitrateMode: "constant",
     opus: {
       frameDuration: duration,
     },
   };

   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()
   await decoder.flush();

   encoder.close();
   decoder.close();

   assert_true(outputs.every((chunk) => chunk.duration === duration));

 }
}, 'Test Opus valid frame durations.');



// The AAC bitrateMode enum chooses whether we use a constant or variable bitrate.
// This test exercises the VBR/CBR paths. Some platforms don't support VBR for AAC,
// and still emit a constant bitrate.
promise_test(async t => {
 let sample_rate = 48000;
 let total_duration_s = 10;
 let data_count = 100;
 let vbr_outputs = [];
 let cbr_outputs = [];

 let cbr_encoder = new AudioEncoder({
   error: e => {
     assert_unreached('error: ' + e);
   },
   output: chunk => {
     cbr_outputs.push(chunk);
   }
 });

 let vbr_encoder = new AudioEncoder({
   error: e => {
     assert_unreached('error: ' + e);
   },
   output: chunk => {
     vbr_outputs.push(chunk);
   }
 });

 let config = {
   codec: 'mp4a.40.2',
   sampleRate: sample_rate,
   numberOfChannels: 2,
   bitrate: 192000,  // 256kbit
 };

 let cbr_config = { ...config, bitrateMode: "constant" };
 let vbr_config = { ...config, bitrateMode: "variable" };

 let cbr_config_support = await AudioEncoder.isConfigSupported(cbr_config);
 assert_implements_optional(cbr_config_support.supported, "AAC CBR not supported");

 let vbr_config_support = await AudioEncoder.isConfigSupported(vbr_config);
 assert_implements_optional(vbr_config_support.supported, "AAC VBR not supported");

 // Configure one encoder with VBR and one CBR.
 cbr_encoder.configure(cbr_config);
 vbr_encoder.configure(vbr_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;

   if (i == 0 || i == (data_count - 1)) {
     // Send real data for the first and last 100ms.
     data = make_audio_data(
       timestamp_us, config.numberOfChannels, config.sampleRate,
       data_length);

   } else {
     // Send silence for the rest of the 10s.
     data = make_silent_audio_data(
       timestamp_us, config.numberOfChannels, config.sampleRate,
       data_length);
   }

   vbr_encoder.encode(data);
   cbr_encoder.encode(data);
   data.close();

   timestamp_us += data_duration_s * 1_000_000;
 }

 await Promise.all([cbr_encoder.flush(), vbr_encoder.flush()])

 cbr_encoder.close();
 vbr_encoder.close();

 let vbr_total_bytes = 0;
 vbr_outputs.forEach(chunk => vbr_total_bytes += chunk.byteLength)

 let cbr_total_bytes = 0;
 cbr_outputs.forEach(chunk => cbr_total_bytes += chunk.byteLength)

 // We'd like to confirm that the encoded size using VBR is less than CBR, but
 // platforms without VBR support will silently revert to CBR (which is
 // technically a subset of VBR).
 assert_less_than_equal(vbr_total_bytes, cbr_total_bytes);
}, 'Test the AAC bitrateMode flag works.');