package net.sf.jack4j.util.file.wav;
   
   import java.io.File;
   import java.io.FileOutputStream;
   import java.io.IOException;
   import java.nio.ByteBuffer;
   import java.nio.ByteOrder;
   import java.nio.channels.FileChannel;
   
  import net.sf.jack4j.util.IntSampleConverter;
  
  /*
  Copyright (C) 2008 Ondrej Par
  
  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.
  
  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  
  */
  
  /**
   * Creates WAV file.
   * 
   * <p>
   * This is very simple writer for WAV files. The instance must be closed after
   * last sample was written.
   */
  public class WavFileWriter {
  
  	private static final int OPTIMAL_BUFFER_SIZE = 4096;
  
  	private FileChannel fileChannel;
  	private IntSampleConverter sampleConverter;
  	private int channelCount;
  	private long totalSizePosition;
  	private long firstChunkPosition;
  	private long dataChunkSizePosition;
  	private int bufferSamples;
  	private int blockAlign;
  	private long dataPosition;
  	private ByteBuffer buffer;
  
  	public WavFileWriter(String fileName, int bitsPerSample, int samplesPerSecond, int channelCount) throws IOException {
  		File file = new File(fileName);
  		FileOutputStream fileOutputStream = new FileOutputStream(file);
  		this.fileChannel = fileOutputStream.getChannel();
  
  		this.sampleConverter = IntSampleConverter.createIntSampleConverter(bitsPerSample, !(bitsPerSample <= 8), false);
  
  		this.channelCount = channelCount;
  
  		this.blockAlign = sampleConverter.bytesPerSample() * channelCount;
  
  		bufferSamples = OPTIMAL_BUFFER_SIZE / blockAlign;
  		if (bufferSamples == 0) {
  			bufferSamples = 1;
  		}
  		this.buffer = ByteBuffer.allocateDirect(bufferSamples * blockAlign).order(ByteOrder.LITTLE_ENDIAN);
  
  		writeHeaders(bitsPerSample, samplesPerSecond);
  	}
  
  	/**
  	 * Writes samples from specified buffers to the WAV file.
  	 * 
  	 * <p>
  	 * Buffers in the given array are used for corresponding channels. If the
  	 * array element at index <code>i</code> is null, the channel
  	 * <code>i</code> will be filled with 0db samples. If the array has less
  	 * elements than the number of channels, channels with higher numbers will
  	 * be all filled with 0db samples. If the array has more elements than the
  	 * number of channels, extra buffers will be ignored.
  	 */
  	public void writeSamples(ByteBuffer[] channelBuffers, int nframes) throws IOException {
  		int remainsToWrite = nframes;
  
  		while (remainsToWrite > 0) {
  			int bufferRemainingSamples = buffer.remaining() / blockAlign;
  			int toWrite = (remainsToWrite < bufferRemainingSamples) ? remainsToWrite : bufferRemainingSamples;
  
  			for (int sampleIdx = 0; sampleIdx < toWrite; sampleIdx++) {
  				for (int channelIdx = 0; channelIdx < channelCount; channelIdx++) {
  					ByteBuffer channelBuffer = (channelIdx < channelBuffers.length) ? channelBuffers[channelIdx] : null;
  					float sample = (channelBuffer == null) ? 0.0f : channelBuffer.getFloat();
  
  					sampleConverter.floatToIntSample(sample, buffer);
  				}
  			}
  
 			if (buffer.remaining() < blockAlign) {
 				flushBuffer();
 			}
 
 			remainsToWrite -= toWrite;
 		}
 	}
 
 	/**
 	 * Closes the file.
 	 * 
 	 * <p>
 	 * This method must be called after the last sample is written. The instance
 	 * is unusable afterwards.
 	 */
 	public void close() throws IOException {
 		flushBuffer();
 
 		long fileSize = fileChannel.position();
 
 		int aiffSize = (int) (fileSize - firstChunkPosition);
 		int dataSize = (int) (fileSize - dataPosition);
 
 		ByteBuffer buffer = ByteBuffer.allocate(Integer.SIZE / 8).order(ByteOrder.LITTLE_ENDIAN);
 
 		fileChannel.position(totalSizePosition);
 		buffer.putInt(aiffSize);
 		buffer.flip();
 		fileChannel.write(buffer);
 
 		fileChannel.position(dataChunkSizePosition);
 		buffer.clear();
 		buffer.putInt(dataSize);
 		buffer.flip();
 		fileChannel.write(buffer);
 
 		fileChannel.close();
 	}
 
 	private void flushBuffer() throws IOException {
 		if (buffer.position() > 0) {
 			buffer.flip();
 			fileChannel.write(buffer);
 			buffer.clear();
 		}
 	}
 
 	private void writeHeaders(int bitsPerSample, int samplesPerSecond) throws IOException {
 		ByteBuffer buffer = ByteBuffer.allocate(1024).order(ByteOrder.LITTLE_ENDIAN);
 
 		buffer.putInt(WavFormat.RIFF_GROUP_ID);
 		buffer.flip();
 		fileChannel.write(buffer);
 		buffer.clear();
 
 		this.totalSizePosition = fileChannel.position();
 
 		buffer.putInt(0); // will be replaced with data size
 		buffer.flip();
 		fileChannel.write(buffer);
 		buffer.clear();
 
 		this.firstChunkPosition = fileChannel.position();
 
 		buffer.putInt(WavFormat.WAVE_FILE_TYPE);
 
 		buffer.putInt(WavFormat.FMT_CHUNK_TYPE);
 		buffer.putInt(WavFormat.FORMAT_FIELDS_SIZE);
 		buffer.putShort((short) WavFormat.REQUIRED_FORMAT_TAG);
 		buffer.putShort((short) channelCount);
 		buffer.putInt(samplesPerSecond);
 		buffer.putInt(blockAlign * samplesPerSecond);
 		buffer.putShort((short) blockAlign);
 		buffer.putShort((short) bitsPerSample);
 
 		buffer.putInt(WavFormat.DATA_CHUNK_TYPE);
 		buffer.flip();
 		fileChannel.write(buffer);
 		buffer.clear();
 
 		this.dataChunkSizePosition = fileChannel.position();
 
 		buffer.putInt(0); // will be replaced with chunk size
 		buffer.flip();
 		fileChannel.write(buffer);
 
 		this.dataPosition = fileChannel.position();
 	}
 }