sdrtrunk/src/record/wave/MonoWaveReader.java

/*******************************************************************************
 * 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");
    }
}