<!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>