content/test/data/gpu/webcodecs/audio-encode-decode.html - chromium/src.git - Git at Google

 <!DOCTYPE html>
 <!--
 Check that AudioDecoder can decode output of AudioEncoder
 -->
 <title>Encode test</title>
 <script src="webcodecs_common.js"></script>
 <script type="text/javascript">
 'use strict';

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

   // This generates samples in a planar format.
   for (var channel = 0; channel < channels; channel++) {
     let hz = 100 + channel * 50; // sound frequency
     let base_index = channel * frames;
     for (var i = 0; i < frames; i++) {
       let t = (i / sampleRate) * hz * (Math.PI * 2);
       data[base_index + i] = Math.sin(t);
     }
   }

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

 async function main(args) {
   let errors = 0;
   let output_count = 0;

   let config = {
     codec: args.codec,
     sampleRate: args.sample_rate,
     numberOfChannels: args.channels,
     bitrate: 96000
   };

   if (args.aac_format) {
     config.aac = {
       format : args.aac_format
     };
   }
   let decoder_config = null;

   let supported = false;
   try {
     supported = (await AudioEncoder.isConfigSupported(config)).supported;
   } catch (e) {}
   if (!supported) {
     TEST.skip('Unsupported codec: ' + args.codec);
     return;
   }

   let total_duration_s = 1.0;
   let data_count = 20; // each chunk is 500 ms
   let outputs = [];
   let init = {
     error: e => {
       errors++;
       TEST.log(e);
     },
     output: (chunk, md) => {
       if (md.decoderConfig) {
         decoder_config = md.decoderConfig;
       }
       outputs.push(chunk);
     }
   };

   // Make some sin() waves and encode them
   let encoder = new AudioEncoder(init);
   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;
     if (i % 10 == 0) {
       // Inserting flushes in the middle, to see how the encoder handles
       // more inputs coming after flush()
       await encoder.flush();
     }

   }
   await encoder.flush();
   encoder.close();

   // Maximum amount of padding from supported encoders. Applied twice, since the
   // flush above can also introduce padding.
   timestamp_us += 2 * (2112 / config.sampleRate) * 1_000_000;

   TEST.assert(decoder_config != null, "No decoder config");
   if (args.aac_format == "adts") {
     TEST.assert(decoder_config.description == null, "ADTS should carry desc");
   } else if (args.aac_format == "aac") {
     TEST.assert(decoder_config.description != null, "AAC should carry desc");
     TEST.assert(decoder_config.description.byteLength > 1,
                 "AAC desc is too short");
   }
   TEST.assert(outputs.length > 0, "no outputs");
   TEST.assert(outputs[0].timestamp == 0, "first chunk timestamp non zero");

   let total_encoded_duration = 0
   for (let chunk of outputs) {
     TEST.assert(chunk.byteLength > 0,  "chunk is empty");
     TEST.assert(timestamp_us >= chunk.timestamp,
         `chunk timestamp is too small. ${timestamp_us} vs ${chunk.timestamp}`);
     TEST.assert(chunk.duration >= 0, "chunk duration is zero");
     total_encoded_duration += chunk.duration;
     let buf = new ArrayBuffer(chunk.byteLength);
     chunk.copyTo(buf);
     if (args.aac_format == "adts") {
       let adts_header = new DataView(buf).getUint8(0);
       TEST.assert(adts_header == 0xff,  "Incorrect ADTS header");
     }
   }

   // The total duration might be padded with silence.
   TEST.assert(
       total_encoded_duration >= total_duration_s * 1_000_000,
       `Unexpected encoded duration: ${total_encoded_duration} us` );


   // Decode output and check that the output still makes sense
   let audio_buffers = [];
   let decoder_init = {
     error: e => {
       errors++;
       TEST.log(e);
     },
     output: (audio_data) => {
       let buffer = new AudioBuffer({
             length: audio_data.numberOfFrames,
             numberOfChannels: audio_data.numberOfChannels,
             sampleRate: audio_data.sampleRate
       });
       for (let i = 0; i < audio_data.numberOfChannels; i++) {
         audio_data.copyTo(buffer.getChannelData(i), {
           planeIndex : i,
           frameOffset : 0,
           frameCount : audio_data.numberOfFrames,
           format : "f32-planar"
         });
       }
       audio_buffers.push(buffer);
       audio_data.close();
     }
   };

   let decoder = new AudioDecoder(decoder_init)
   decoder.configure(decoder_config);
   for (let chunk of outputs) {
     decoder.decode(chunk);
   }
   await decoder.flush();

   let total_decoded_duration_s = 0.0;
   for (let buffer of audio_buffers) {
     total_decoded_duration_s += buffer.duration;
     TEST.assert(buffer.numberOfChannels == config.numberOfChannels,
                 "unexpected number of channels");
   }

   TEST.assert(errors == 0, "errors: " + errors);

   // The total duration might be padded with silence, but no too much.
   TEST.assert(
     total_decoded_duration_s >= total_duration_s,
       `Decoded duration is too short: ${total_decoded_duration_s} s`);
       TEST.assert(
     total_decoded_duration_s < 2 * total_duration_s,
       `Decoded duration is too long: ${total_decoded_duration_s} s`);
 }
 </script>
	<!DOCTYPE html>
	<!--
	Check that AudioDecoder can decode output of AudioEncoder
	-->
	<title>Encode test</title>
	<script src="webcodecs_common.js"></script>
	<script type="text/javascript">
	'use strict';

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

	// This generates samples in a planar format.
	for (var channel = 0; channel < channels; channel++) {
	let hz = 100 + channel * 50; // sound frequency
	let base_index = channel * frames;
	for (var i = 0; i < frames; i++) {
	let t = (i / sampleRate) * hz * (Math.PI * 2);
	data[base_index + i] = Math.sin(t);
	}
	}

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

	async function main(args) {
	let errors = 0;
	let output_count = 0;

	let config = {
	codec: args.codec,
	sampleRate: args.sample_rate,
	numberOfChannels: args.channels,
	bitrate: 96000
	};

	if (args.aac_format) {
	config.aac = {
	format : args.aac_format
	};
	}
	let decoder_config = null;

	let supported = false;
	try {
	supported = (await AudioEncoder.isConfigSupported(config)).supported;
	} catch (e) {}
	if (!supported) {
	TEST.skip('Unsupported codec: ' + args.codec);
	return;
	}

	let total_duration_s = 1.0;
	let data_count = 20; // each chunk is 500 ms
	let outputs = [];
	let init = {
	error: e => {
	errors++;
	TEST.log(e);
	},
	output: (chunk, md) => {
	if (md.decoderConfig) {
	decoder_config = md.decoderConfig;
	}
	outputs.push(chunk);
	}
	};

	// Make some sin() waves and encode them
	let encoder = new AudioEncoder(init);
	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;
	if (i % 10 == 0) {
	// Inserting flushes in the middle, to see how the encoder handles
	// more inputs coming after flush()
	await encoder.flush();
	}

	}
	await encoder.flush();
	encoder.close();

	// Maximum amount of padding from supported encoders. Applied twice, since the
	// flush above can also introduce padding.
	timestamp_us += 2 * (2112 / config.sampleRate) * 1_000_000;

	TEST.assert(decoder_config != null, "No decoder config");
	if (args.aac_format == "adts") {
	TEST.assert(decoder_config.description == null, "ADTS should carry desc");
	} else if (args.aac_format == "aac") {
	TEST.assert(decoder_config.description != null, "AAC should carry desc");
	TEST.assert(decoder_config.description.byteLength > 1,
	"AAC desc is too short");
	}
	TEST.assert(outputs.length > 0, "no outputs");
	TEST.assert(outputs[0].timestamp == 0, "first chunk timestamp non zero");

	let total_encoded_duration = 0
	for (let chunk of outputs) {
	TEST.assert(chunk.byteLength > 0, "chunk is empty");
	TEST.assert(timestamp_us >= chunk.timestamp,
	`chunk timestamp is too small. ${timestamp_us} vs ${chunk.timestamp}`);
	TEST.assert(chunk.duration >= 0, "chunk duration is zero");
	total_encoded_duration += chunk.duration;
	let buf = new ArrayBuffer(chunk.byteLength);
	chunk.copyTo(buf);
	if (args.aac_format == "adts") {
	let adts_header = new DataView(buf).getUint8(0);
	TEST.assert(adts_header == 0xff, "Incorrect ADTS header");
	}
	}

	// The total duration might be padded with silence.
	TEST.assert(
	total_encoded_duration >= total_duration_s * 1_000_000,
	`Unexpected encoded duration: ${total_encoded_duration} us` );


	// Decode output and check that the output still makes sense
	let audio_buffers = [];
	let decoder_init = {
	error: e => {
	errors++;
	TEST.log(e);
	},
	output: (audio_data) => {
	let buffer = new AudioBuffer({
	length: audio_data.numberOfFrames,
	numberOfChannels: audio_data.numberOfChannels,
	sampleRate: audio_data.sampleRate
	});
	for (let i = 0; i < audio_data.numberOfChannels; i++) {
	audio_data.copyTo(buffer.getChannelData(i), {
	planeIndex : i,
	frameOffset : 0,
	frameCount : audio_data.numberOfFrames,
	format : "f32-planar"
	});
	}
	audio_buffers.push(buffer);
	audio_data.close();
	}
	};

	let decoder = new AudioDecoder(decoder_init)
	decoder.configure(decoder_config);
	for (let chunk of outputs) {
	decoder.decode(chunk);
	}
	await decoder.flush();

	let total_decoded_duration_s = 0.0;
	for (let buffer of audio_buffers) {
	total_decoded_duration_s += buffer.duration;
	TEST.assert(buffer.numberOfChannels == config.numberOfChannels,
	"unexpected number of channels");
	}

	TEST.assert(errors == 0, "errors: " + errors);

	// The total duration might be padded with silence, but no too much.
	TEST.assert(
	total_decoded_duration_s >= total_duration_s,
	`Decoded duration is too short: ${total_decoded_duration_s} s`);
	TEST.assert(
	total_decoded_duration_s < 2 * total_duration_s,
	`Decoded duration is too long: ${total_decoded_duration_s} s`);
	}
	</script>