public static void main(String[] args) {
    if (args.length < 1) {
      System.err.println("Must supply filename");
      System.exit(1);
    }

    try {
      for (final String filename : args) {
        final WavFile readWavFile = openWavFile(new File(filename));
        readWavFile.display();

        final long numFrames = readWavFile.getNumFrames();
        final int numChannels = readWavFile.getNumChannels();
        final int validBits = readWavFile.getValidBits();
        final long sampleRate = readWavFile.getSampleRate();

        final WavFile writeWavFile =
            newWavFile(new File("out.wav"), numChannels, numFrames, validBits, sampleRate);

        final int BUF_SIZE = 5001;

        //				int[] buffer = new int[BUF_SIZE * numChannels];
        //				long[] buffer = new long[BUF_SIZE * numChannels];
        final double[] buffer = new double[BUF_SIZE * numChannels];

        int framesRead = 0;
        int framesWritten = 0;

        do {
          framesRead = readWavFile.readFrames(buffer, BUF_SIZE);
          framesWritten = writeWavFile.writeFrames(buffer, BUF_SIZE);
          System.out.printf("%d %d\n", framesRead, framesWritten);
        } while (framesRead != 0);

        readWavFile.close();
        writeWavFile.close();
      }

      final WavFile writeWavFile = newWavFile(new File("out2.wav"), 1, 10, 23, 44100);
      final double[] buffer = new double[10];
      writeWavFile.writeFrames(buffer, 10);
      writeWavFile.close();
    } catch (final Exception e) {
      System.err.println(e);
      e.printStackTrace();
    }
  }
  public static WavFile newWavFile(
      File file, int numChannels, long numFrames, int validBits, long sampleRate)
      throws IOException, WavFileException {
    // Instantiate new Wavfile and initialise
    final WavFile wavFile = new WavFile();
    wavFile.file = file;
    wavFile.numChannels = numChannels;
    wavFile.numFrames = numFrames;
    wavFile.sampleRate = sampleRate;
    wavFile.bytesPerSample = (validBits + 7) / 8;
    wavFile.blockAlign = wavFile.bytesPerSample * numChannels;
    wavFile.validBits = validBits;

    // Sanity check arguments
    if ((numChannels < 1) || (numChannels > 65535)) {
      throw new WavFileException("Illegal number of channels, valid range 1 to 65536");
    }
    if (numFrames < 0) {
      throw new WavFileException("Number of frames must be positive");
    }
    if ((validBits < 2) || (validBits > 65535)) {
      throw new WavFileException("Illegal number of valid bits, valid range 2 to 65536");
    }
    if (sampleRate < 0) {
      throw new WavFileException("Sample rate must be positive");
    }

    // Create output stream for writing data
    wavFile.oStream = new FileOutputStream(file);

    // Calculate the chunk sizes
    final long dataChunkSize = wavFile.blockAlign * numFrames;
    long mainChunkSize =
        4
            + // Riff Type
            8
            + // Format ID and size
            16
            + // Format data
            8
            + // Data ID and size
            dataChunkSize;

    // Chunks must be word aligned, so if odd number of audio data bytes
    // adjust the main chunk size
    if ((dataChunkSize % 2) == 1) {
      mainChunkSize += 1;
      wavFile.wordAlignAdjust = true;
    } else {
      wavFile.wordAlignAdjust = false;
    }

    // Set the main chunk size
    putLE(RIFF_CHUNK_ID, wavFile.buffer, 0, 4);
    putLE(mainChunkSize, wavFile.buffer, 4, 4);
    putLE(RIFF_TYPE_ID, wavFile.buffer, 8, 4);

    // Write out the header
    wavFile.oStream.write(wavFile.buffer, 0, 12);

    // Put format data in buffer
    final long averageBytesPerSecond = sampleRate * wavFile.blockAlign;

    putLE(FMT_CHUNK_ID, wavFile.buffer, 0, 4); // Chunk ID
    putLE(16, wavFile.buffer, 4, 4); // Chunk Data Size
    putLE(1, wavFile.buffer, 8, 2); // Compression Code (Uncompressed)
    putLE(numChannels, wavFile.buffer, 10, 2); // Number of channels
    putLE(sampleRate, wavFile.buffer, 12, 4); // Sample Rate
    putLE(averageBytesPerSecond, wavFile.buffer, 16, 4); // Average Bytes Per Second
    putLE(wavFile.blockAlign, wavFile.buffer, 20, 2); // Block Align
    putLE(validBits, wavFile.buffer, 22, 2); // Valid Bits

    // Write Format Chunk
    wavFile.oStream.write(wavFile.buffer, 0, 24);

    // Start Data Chunk
    putLE(DATA_CHUNK_ID, wavFile.buffer, 0, 4); // Chunk ID
    putLE(dataChunkSize, wavFile.buffer, 4, 4); // Chunk Data Size

    // Write Format Chunk
    wavFile.oStream.write(wavFile.buffer, 0, 8);

    // Calculate the scaling factor for converting to a normalised double
    if (wavFile.validBits > 8) {
      // If more than 8 validBits, data is signed
      // Conversion required multiplying by magnitude of max positive value
      wavFile.floatOffset = 0;
      wavFile.floatScale = Long.MAX_VALUE >> (64 - wavFile.validBits);
    } else {
      // Else if 8 or less validBits, data is unsigned
      // Conversion required dividing by max positive value
      wavFile.floatOffset = 1;
      wavFile.floatScale = 0.5 * ((1 << wavFile.validBits) - 1);
    }

    // Finally, set the IO State
    wavFile.bufferPointer = 0;
    wavFile.bytesRead = 0;
    wavFile.frameCounter = 0;
    wavFile.ioState = IOState.WRITING;

    return wavFile;
  }
  public static WavFile openWavFile(File file) throws IOException, WavFileException {
    // Instantiate new Wavfile and store the file reference
    final WavFile wavFile = new WavFile();
    wavFile.file = file;

    // Create a new file input stream for reading file data
    wavFile.iStream = new FileInputStream(file);

    // Read the first 12 bytes of the file
    int bytesRead = wavFile.iStream.read(wavFile.buffer, 0, 12);
    if (bytesRead != 12) {
      throw new WavFileException("Not enough wav file bytes for header");
    }

    // Extract parts from the header
    final long riffChunkID = getLE(wavFile.buffer, 0, 4);
    long chunkSize = getLE(wavFile.buffer, 4, 4);
    final long riffTypeID = getLE(wavFile.buffer, 8, 4);

    // Check the header bytes contains the correct signature
    if (riffChunkID != RIFF_CHUNK_ID) {
      throw new WavFileException("Invalid Wav Header data, incorrect riff chunk ID");
    }
    if (riffTypeID != RIFF_TYPE_ID) {
      throw new WavFileException("Invalid Wav Header data, incorrect riff type ID");
    }

    // Check that the file size matches the number of bytes listed in header
    if (file.length() != (chunkSize + 8)) {
      throw new WavFileException(
          "Header chunk size (" + chunkSize + ") does not match file size (" + file.length() + ")");
    }

    boolean foundFormat = false;
    boolean foundData = false;

    // Search for the Format and Data Chunks
    while (true) {
      // Read the first 8 bytes of the chunk (ID and chunk size)
      bytesRead = wavFile.iStream.read(wavFile.buffer, 0, 8);
      if (bytesRead == -1) {
        throw new WavFileException("Reached end of file without finding format chunk");
      }
      if (bytesRead != 8) {
        throw new WavFileException("Could not read chunk header");
      }

      // Extract the chunk ID and Size
      final long chunkID = getLE(wavFile.buffer, 0, 4);
      chunkSize = getLE(wavFile.buffer, 4, 4);

      // Word align the chunk size
      // chunkSize specifies the number of bytes holding data. However,
      // the data should be word aligned (2 bytes) so we need to calculate
      // the actual number of bytes in the chunk
      long numChunkBytes = ((chunkSize % 2) == 1) ? chunkSize + 1 : chunkSize;

      if (chunkID == FMT_CHUNK_ID) {
        // Flag that the format chunk has been found
        foundFormat = true;

        // Read in the header info
        bytesRead = wavFile.iStream.read(wavFile.buffer, 0, 16);

        // Check this is uncompressed data
        final int compressionCode = (int) getLE(wavFile.buffer, 0, 2);
        if (compressionCode != 1) {
          throw new WavFileException("Compression Code " + compressionCode + " not supported");
        }

        // Extract the format information
        wavFile.numChannels = (int) getLE(wavFile.buffer, 2, 2);
        wavFile.sampleRate = getLE(wavFile.buffer, 4, 4);
        wavFile.blockAlign = (int) getLE(wavFile.buffer, 12, 2);
        wavFile.validBits = (int) getLE(wavFile.buffer, 14, 2);

        if (wavFile.numChannels == 0) {
          throw new WavFileException("Number of channels specified in header is equal to zero");
        }
        if (wavFile.blockAlign == 0) {
          throw new WavFileException("Block Align specified in header is equal to zero");
        }
        if (wavFile.validBits < 2) {
          throw new WavFileException("Valid Bits specified in header is less than 2");
        }
        if (wavFile.validBits > 64) {
          throw new WavFileException(
              "Valid Bits specified in header is greater than 64, this is greater than a long can hold");
        }

        // Calculate the number of bytes required to hold 1 sample
        wavFile.bytesPerSample = (wavFile.validBits + 7) / 8;
        if ((wavFile.bytesPerSample * wavFile.numChannels) != wavFile.blockAlign) {
          throw new WavFileException(
              "Block Align does not agree with bytes required for validBits and number of channels");
        }

        // Account for number of format bytes and then skip over
        // any extra format bytes
        numChunkBytes -= 16;
        if (numChunkBytes > 0) {
          wavFile.iStream.skip(numChunkBytes);
        }
      } else if (chunkID == DATA_CHUNK_ID) {
        // Check if we've found the format chunk,
        // If not, throw an exception as we need the format information
        // before we can read the data chunk
        if (foundFormat == false) {
          throw new WavFileException("Data chunk found before Format chunk");
        }

        // Check that the chunkSize (wav data length) is a multiple of the
        // block align (bytes per frame)
        if ((chunkSize % wavFile.blockAlign) != 0) {
          throw new WavFileException("Data Chunk size is not multiple of Block Align");
        }

        // Calculate the number of frames
        wavFile.numFrames = chunkSize / wavFile.blockAlign;

        // Flag that we've found the wave data chunk
        foundData = true;

        break;
      } else {
        // If an unknown chunk ID is found, just skip over the chunk data
        wavFile.iStream.skip(numChunkBytes);
      }
    }

    // Throw an exception if no data chunk has been found
    if (foundData == false) {
      throw new WavFileException("Did not find a data chunk");
    }

    // Calculate the scaling factor for converting to a normalised double
    if (wavFile.validBits > 8) {
      // If more than 8 validBits, data is signed
      // Conversion required dividing by magnitude of max negative value
      wavFile.floatOffset = 0;
      wavFile.floatScale = 1 << (wavFile.validBits - 1);
    } else {
      // Else if 8 or less validBits, data is unsigned
      // Conversion required dividing by max positive value
      wavFile.floatOffset = -1;
      wavFile.floatScale = 0.5 * ((1 << wavFile.validBits) - 1);
    }

    wavFile.bufferPointer = 0;
    wavFile.bytesRead = 0;
    wavFile.frameCounter = 0;
    wavFile.ioState = IOState.READING;

    return wavFile;
  }