#30 - WIP Streaming audio support. Adds Shoutcast V1 handler.

src/record/wave/MonoWaveReader.java

@@ -0,0 +1,257 @@
+/*******************************************************************************
+ * 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.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]; //500 milliseconds of audio
+
+    /**
+     * 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
+	{
+		assert( 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");
+    }
+}