package net.sf.jack4j.util.file.wav;
   
   /*
   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.
  
  */
  
  import java.io.IOException;
  import java.nio.ByteBuffer;
  import java.nio.ByteOrder;
  import java.nio.channels.FileChannel;
  
  import net.sf.jack4j.util.IntSampleConverter;
  
  /**
   * Allows read-only access to WAV file.
   * 
   * <p>
   * The class uses dedicated {@link FileChannel} instance that must be passed to
   * the constructor and may not be used by anyone else.
   * 
   * @author repa
   * 
   */
  public class WavFileReader {
  
  	private static final int OPTIMAL_BUFFER_SIZE = 4096;
  
  	private FileChannel fileChannel;
  	private IntSampleConverter sampleConverter;
  	private int bitsPerSample;
  	private int samplesPerSecond;
  	private int channelCount;
  	private int blockAlign;
  	private int avgBytesPerSecond;
  	private long dataPosition;
  	private long dataSize;
  	private ByteBuffer buffer;
  	private int bufferSamples;
  	private long currentSample;
  	private long totalSamples;
  
  	public WavFileReader(FileChannel fileChannel) throws IOException {
  		this.fileChannel = fileChannel;
  
  		parseHeaders();
  
  		bufferSamples = OPTIMAL_BUFFER_SIZE / blockAlign;
  		if (bufferSamples == 0) {
  			bufferSamples = 1;
  		}
  		this.buffer = ByteBuffer.allocateDirect(bufferSamples * blockAlign);
  
  		initialSeek();
  	}
  
  	/**
  	 * Reads samples from WAV file, starting at current position, and writes
  	 * them to specified buffers.
  	 * 
  	 * <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 not be processed. If the array has less elements
  	 * than the number of channels, channels with higher numbers will not be
  	 * processed. If the array has more elements than the number of channels,
  	 * zero samples (0.0f) will be put into unused buffers.
  	 * 
  	 * @return number of samples read
  	 */
  	public int readSamples(ByteBuffer[] channelBuffers, int nframes) throws IOException {
  		int totalRead = 0;
  		int remainsToRead = nframes;
  
  		while (remainsToRead > 0) {
  			long remainingSamples = totalSamples - currentSample;
  			int toRead = (remainsToRead < remainingSamples) ? remainsToRead : (int) remainingSamples;
  			if (toRead == 0) {
  				break;
  			} else if (toRead > bufferSamples) {
  				toRead = bufferSamples;
  			}
  
  			buffer.clear();
  			buffer.limit(toRead * blockAlign);
 			int bytesRead = fileChannel.read(buffer);
 			if (bytesRead == -1) {
 				break;
 			}
 			buffer.flip();
 			int samplesRead = bytesRead / blockAlign;
 
 			for (int sampleIdx = 0; sampleIdx < samplesRead; sampleIdx++) {
 				for (int channelIdx = 0; channelIdx < channelCount; channelIdx++) {
 					float sample = sampleConverter.intSampleToFloat(buffer);
 
 					if (channelIdx >= channelBuffers.length) {
 						continue;
 					}
 					ByteBuffer channelBuffer = channelBuffers[channelIdx];
 					if (channelBuffer == null) {
 						continue;
 					}
 
 					channelBuffer.putFloat(sample);
 				}
 				for (int channelIdx = channelCount; channelIdx < channelBuffers.length; channelIdx++) {
 					ByteBuffer channelBuffer = channelBuffers[channelIdx];
 					if (channelBuffer == null) {
 						continue;
 					}
 					channelBuffer.putFloat(0.0f);
 				}
 			}
 
 			totalRead += samplesRead;
 			currentSample += samplesRead;
 			remainsToRead -= samplesRead;
 		}
 
 		return totalRead;
 	}
 
 	private void parseHeaders() throws IOException {
 		ByteBuffer buffer = ByteBuffer.allocate(1024).order(ByteOrder.LITTLE_ENDIAN);
 
 		fileChannel.position(0);
 		readBytesToBuffer(buffer, WavFormat.AIFF_HEADER_LENGTH);
 		buffer.flip();
 
 		if (buffer.getInt() != WavFormat.RIFF_GROUP_ID) {
 			throw new IOException("Wrong AIFF groupId");
 		}
 
 		long totalDataSize = 0xffffffffL & (buffer.getInt());
 		long maxPosition = buffer.position() + totalDataSize;
 
 		if (buffer.getInt() != WavFormat.WAVE_FILE_TYPE) {
 			throw new IOException("Wrong RIFF file type");
 		}
 
 		while (fileChannel.position() < maxPosition) {
 			readBytesToBuffer(buffer, WavFormat.CHUNK_HEADER_LENGTH);
 			buffer.flip();
 
 			int chunkType = buffer.getInt();
 			long chunkSize = 0xffffffffL & (buffer.getInt());
 			long paddedChunkSize = (chunkSize % 2 == 0) ? chunkSize : chunkSize + 1;
 
 			long chunkStartPosition = fileChannel.position();
 
 			if (chunkType == WavFormat.FMT_CHUNK_TYPE) {
 				readBytesToBuffer(buffer, WavFormat.FORMAT_FIELDS_SIZE);
 				buffer.flip();
 
 				int formatTag = buffer.getShort();
 				if (formatTag != WavFormat.REQUIRED_FORMAT_TAG) {
 					throw new UnsupportedOperationException("Unsupported WAV format #" + formatTag);
 				}
 				channelCount = buffer.getShort();
 				samplesPerSecond = buffer.getInt();
 				avgBytesPerSecond = buffer.getInt();
 				blockAlign = buffer.getShort();
 				bitsPerSample = buffer.getShort();
 
 				sampleConverter = IntSampleConverter.createIntSampleConverter(bitsPerSample,
 				        !(bitsPerSample <= 8),
 				        false);
 			} else if (chunkType == WavFormat.DATA_CHUNK_TYPE) {
 				dataPosition = chunkStartPosition;
 				dataSize = chunkSize;
 			}
 
 			fileChannel.position(chunkStartPosition + paddedChunkSize);
 		}
 	}
 
 	private void initialSeek() throws IOException {
 		fileChannel.position(dataPosition);
 		currentSample = 0;
 		totalSamples = dataSize / blockAlign;
 	}
 
 	private void readBytesToBuffer(ByteBuffer buffer, int size) throws IOException {
 		buffer.clear();
 		buffer.limit(size);
 		if (fileChannel.read(buffer) != size) {
 			throw new IOException("Can't read " + size + " bytes from WAV file");
 		}
 	}
 
 	/**
 	 * @return the bitsPerSample
 	 */
 	public int getBitsPerSample() {
 		return bitsPerSample;
 	}
 
 	/**
 	 * @return the samplesPerSecond
 	 */
 	public int getSamplesPerSecond() {
 		return samplesPerSecond;
 	}
 
 	/**
 	 * @return the channelCount
 	 */
 	public int getChannelCount() {
 		return channelCount;
 	}
 
 	/**
 	 * @return the blockAlign
 	 */
 	public int getBlockAlign() {
 		return blockAlign;
 	}
 
 	/**
 	 * @return the avgBytesPerSecond
 	 */
 	public int getAvgBytesPerSecond() {
 		return avgBytesPerSecond;
 	}
 }