/*******************************************************************************
* sdrtrunk
* Copyright (C) 2014-2016 Dennis Sheirer
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>
*
******************************************************************************/
package record.wave;
import org.apache.commons.lang3.Validate;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import sample.ConversionUtils;
import sample.Listener;
import sample.real.RealBuffer;
import java.io.IOException;
import java.io.InputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.ShortBuffer;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.Arrays;
import java.util.regex.Pattern;
public class MonoWaveReader implements AutoCloseable
{
private final static Logger mLog = LoggerFactory.getLogger( MonoWaveReader.class);
private static final Pattern FILENAME_PATTERN = Pattern.compile( "(.*_)(\\d+)(\\.wav)" );
private Path mPath;
private boolean mRealTime;
private InputStream mInputStream;
private int mDataByteSize = 0;
private Listener<RealBuffer> mListener;
private byte[] mDataBuffer = new byte[8000];
/**
* Wave file reader for PCM 8kHz, 16-bit little-endian format.
*
* @param path of the wave file
* @param realTime to force replay to real-time. Note: you should run this reader on a separate thread if you
* choose real time since this reader will sleep the calling thread as needed to effect real-time playback.
*/
public MonoWaveReader(Path path, boolean realTime) throws IOException
{
Validate.isTrue(path != null);
mPath = path;
mRealTime = realTime;
open();
}
/**
* Opens the file
*/
private void open() throws IOException
{
if(!Files.exists(mPath))
{
throw new IOException("File not found");
}
mInputStream = Files.newInputStream(mPath, StandardOpenOption.READ);
//Check for RIFF header
byte[] buffer = new byte[4];
mInputStream.read(buffer);
if(!Arrays.equals(buffer, WaveUtils.RIFF_CHUNK))
{
throw new IOException("File is not .wav format - missing RIFF chunk");
}
//Get file size
mInputStream.read(buffer);
int fileSize = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get();
//Check for WAVE format
mInputStream.read(buffer);
if(!Arrays.equals(buffer, WaveUtils.WAV_FORMAT))
{
throw new IOException("File is not .wav format - missing WAVE format");
}
//Check for format chunk
mInputStream.read(buffer);
if(!Arrays.equals(buffer, WaveUtils.CHUNK_FORMAT))
{
throw new IOException("File is not .wav format - missing format chunk");
}
//Get chunk size
mInputStream.read(buffer);
int chunkSize = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get();
//Get format
mInputStream.read(buffer);
ShortBuffer shortBuffer = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer();
short format = shortBuffer.get();
if(format != WaveUtils.PCM_FORMAT)
{
throw new IOException("File format not supported - expecting PCM format");
}
//Get number of channels
short channels = shortBuffer.get();
if(channels != 1)
{
throw new IOException("Unsupported channel count - mono audio only");
}
//Get samples per second
mInputStream.read(buffer);
int sampleRate = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get();
//Get bytes per second
mInputStream.read(buffer);
int bytesPerSecond = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get();
mInputStream.read(buffer);
//Get frame size
shortBuffer = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer();
short frameSize = shortBuffer.get();
if(frameSize != 2)
{
throw new IOException("PCM frame size not supported - expecting 2 bytes per frame");
}
//Get bits per sample
short bitsPerSample = shortBuffer.get();
if(bitsPerSample != 16)
{
throw new IOException("PCM sample size not supported - expecting 16 bits per sample");
}
mInputStream.read(buffer);
if(!Arrays.equals(buffer, WaveUtils.CHUNK_DATA))
{
throw new IOException("Unexpected chunk - expecting data chunk");
}
//Get data chunk size
mInputStream.read(buffer);
mDataByteSize = ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get();
}
public void read() throws IOException
{
long start = System.currentTimeMillis();
long samplesRead = 0;
int totalBytesRead = 0;
while(totalBytesRead < mDataByteSize)
{
int bytesRead = mInputStream.read(mDataBuffer);
totalBytesRead += bytesRead;
float[] samples = ConversionUtils.convertFromSigned16BitSamples(mDataBuffer);
if(bytesRead != mDataBuffer.length)
{
samples = Arrays.copyOf(samples, bytesRead / 2);
}
if(mRealTime)
{
samplesRead += samples.length;
long actualElapsed = System.currentTimeMillis() - start;
long audioElapsed = (long)(((double)samplesRead / 8000.0) * 1000.0);
if(audioElapsed > actualElapsed)
{
try
{
Thread.sleep(audioElapsed - actualElapsed);
}
catch (InterruptedException e)
{
}
}
}
if(mListener != null)
{
mListener.receive(new RealBuffer(samples));
}
}
close();
}
public void setListener(Listener<RealBuffer> listener)
{
mListener = listener;
}
/**
* Closes the file
*/
public void close() throws IOException
{
if(mInputStream != null)
{
mInputStream.close();
}
}
public static void main(String[] args)
{
Path path = Paths.get("/home/denny/Music/PCM.wav");
mLog.debug("Opening: " + path.toString());
try
{
MonoWaveReader reader = new MonoWaveReader(path, true);
reader.setListener(new Listener<RealBuffer>()
{
@Override
public void receive(RealBuffer realBuffer)
{
mLog.debug("Received buffer");
}
});
reader.read();
}
catch(IOException e)
{
mLog.error("Error", e);
}
mLog.debug("Finished");
}
}