// https://github.com/s4l4x/audio-analysis/blob/master/src/com/badlogic/audio/io/WaveDecoder.java

/**

 * A simple class that can read in the PCM data from a

 * Wav file, converting the data to signed 32-bit floats

 * in the range [-1,1], merging stereo channels to a mono

 * channel for processing. This only supports 16-bit signed

 * stereo and mono Wav files with a sampling rate of 44100.

 * 

 * @author mzechner

 *

 */

sclass WAVDecoder /*implements com.badlogic.audio.io.Decoder*/ implements AutoCloseable {

  /** the input stream we read from **/

  EndianDataInputStream in;

  /** number of channels **/

  int channels;

  /** sample rate in Herz**/

  float sampleRate;

  bool ignoreSampleRate = true;

  bool twentyFourBit;

  // data length in bytes according to header

  int specifiedDataLength;

  int remainingDataBytes;

  static int defaultBufferSize = 128*1024; //1024*1024

  *(File wavFile) {

    this(fileInputStream(wavFile));

  }

  *(InputStream stream) ctex {

    in = new EndianDataInputStream( new BufferedInputStream( stream, defaultBufferSize) );

    if( !in.read4ByteString().equals( "RIFF" ) )

      throw new IllegalArgumentException( "not a wav" );

    in.readIntLittleEndian();

    if( !in.read4ByteString().equals( "WAVE" ) )

      throw new IllegalArgumentException( "expected WAVE tag" );

    S s = in.read4ByteString();

    if (eq(s, "bext")) { // skip extension block

      in.skip(in.readIntLittleEndian());

      s = in.read4ByteString();

    }

    if (!s.equals("fmt "))

      throw new IllegalArgumentException( "expected fmt tag, got: " + s);

    if( in.readIntLittleEndian() != 16 )

      throw new IllegalArgumentException( "expected wave chunk size to be 16" );

    int format;

    if ((format = in.readShortLittleEndian()) != 1)

      throw new IllegalArgumentException( "expected format to be 1, got: " + format);

    channels = in.readShortLittleEndian();

    //print("Channels: " + channels);

    sampleRate = in.readIntLittleEndian();

    if (sampleRate != 44100)

      if (ignoreSampleRate) {

        // print("Sample rate: " + sampleRate);

      } else

        fail("Not 44100 sampling rate: " + sampleRate);

    in.readIntLittleEndian();

    in.readShortLittleEndian();

    int fmt = in.readShortLittleEndian();

    if (fmt == 24) twentyFourBit = true;

    else if (fmt != 16)

      fail("Only 16/24-bit samples supported: " + fmt);

    S tag;

    while (!(tag = in.read4ByteString()).equals("data")) {

      //print("Skipping tag " + tag);

      //fail( "expected data tag, got: " + tag);

      int len = in.readIntLittleEndian();

      in.skip(len);

    }

    remainingDataBytes = specifiedDataLength = in.readIntLittleEndian();

  }

  /**

   * Tries to read in samples.length samples, merging stereo to a mono

   * channel by averaging and converting non float formats to float 32-bit.

   * Returns the number of samples actually read. Guarantees that samples.length

   * samples are read in if there was enough data in the stream.

   * 

   * @param samples The samples array to write the samples to

   * @return The number of samples actually read.

   */

  public int readMonoSamples(short[] samples, int n default samples.length) {

    int readSamples = 0;

    for (int i = 0; i < n && remainingDataBytes > 0; i++) {

      double sample = 0; 

      try {

        for j to channels:

          sample += readSample();

        sample /= channels;

        samples[i] = (short) iround(max(-32768, min(32767, sample)));

        readSamples++;

      }

      catch (Exception ex) { break; } // ouch

    }

    ret readSamples; 

  }

  public int readStereoSamples(short[] samples, int n default samples.length) {

    int readSamples = 0;

    for (int i = 0; i < n && remainingDataBytes > 0; i += 2) {

      double sample = 0; 

      try {

        short left = readSample();

        short right;

        if (channels > 1)

          right = readSample();

        else

          right = left;

        samples[i] = left;

        samples[i+1] = right;

        readSamples += 2;

      }

      catch (Exception ex) { break; } // ouch

    }

    ret readSamples; 

  }

  short readSample() ctex {

    if (twentyFourBit) { --remainingDataBytes; in.read(); }

    remainingDataBytes -= 2;

    ret in.readShortLittleEndian();

  }

  int bytesPerValue() { ret twentyFourBit ? 3 : 2; }

  int totalValues() { ret specifiedDataLength/bytesPerValue(); }

  // skips this number of samples (what is the terminology again

  // for 1 value vs <channels> values)

  public void skipSamples(long samples) ctex {

    long bytesToSkip = samples*channels*bytesPerValue();

    remainingDataBytes -= bytesToSkip;

    in.skip(bytesToSkip);

  }

  public void close() ctex { in.close(); }

}