Move files in anticipation of move to modular system

2016-07-03 12:28:35 +01:00
commit 5a6ca8046c
33 changed files with 3939 additions and 0 deletions
--- a/src/main/java/old/Converter.java
+++ b/src/main/java/old/Converter.java
@@ -0,0 +1,187 @@
+package old;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import javazoom.jl.decoder.Bitstream;
+import javazoom.jl.decoder.BitstreamException;
+import sound.util.Utils;
+import base.exception.worker.ActivateException;
+import base.exception.worker.DeactivateException;
+import base.work.Work;
+
+import com.Ostermiller.util.CircularByteBuffer;
+
+public class Converter extends Work {
+    public static final String COMMAND = "lame --mp3input --cbr %s - - --quiet";
+    public static final int BYTES = 4096;     // bytes
+    public static final int BUFFER = 30000;   // milliseconds
+    public static final int BUFFERING = 1000; // milliseconds
+
+    protected int targetRate;
+    protected int rate;
+    protected int buffer;
+    protected boolean convert;
+
+    protected Process process;
+    protected InputStream sourceInputStream, processInputStream, inputStream;
+    protected OutputStream processOutputStream;
+    protected CircularByteBuffer circularByteBuffer;
+    protected BufferWorker bufferWorker;
+
+    public Converter(InputStream inputStream) {
+        this(inputStream, -1);        
+    }
+
+    public Converter(InputStream inputStream, int targetRate) {
+        super();
+        this.sourceInputStream = inputStream;
+        this.targetRate = targetRate;
+        bufferWorker = new BufferWorker();
+        convert = false;
+    }
+    
+    public void exit() {
+        super.exit();
+        bufferWorker.exit();
+    }
+
+    public synchronized void activate() throws ActivateException {
+        /* Read bitrate */
+        BufferedInputStream bufferedInputStream = new BufferedInputStream(sourceInputStream);
+        Bitstream bitStream = new Bitstream(bufferedInputStream);
+        try {
+            rate = bitStream.readFrame().bitrate() / 1000;
+            buffer = BUFFER * rate / 8;
+        } catch (BitstreamException e) {
+            logger.error("", e);
+            throw new ActivateException();
+        }
+
+        /* Check for need to convert */
+        if (targetRate < 0 || rate == targetRate) {
+            logger.debug("No conversion required");
+            inputStream = sourceInputStream;
+        } else {
+            logger.debug("Converting from " + rate + "kbps to " + targetRate + "kbps");
+            try {
+                String command = String.format(COMMAND, rate > targetRate ? "-B " + targetRate : "-F -b " + targetRate);
+                logger.debug("Starting process: " + command);
+                process = Runtime.getRuntime().exec(command);
+                processInputStream = process.getInputStream();
+                processOutputStream = process.getOutputStream();
+
+                /* Buffer output */
+                circularByteBuffer = new CircularByteBuffer(CircularByteBuffer.INFINITE_SIZE);
+                inputStream = circularByteBuffer.getInputStream();
+                bufferWorker.start();
+                convert = true;
+            } catch (IOException e) {
+                logger.error("", e);
+                throw new ActivateException();
+            }
+        }
+        super.activate();
+        notifyAll();
+    }
+
+    public void deactivate() throws DeactivateException {
+        super.deactivate();
+        try {
+            sourceInputStream.close();
+            bufferWorker.stop();
+            if (convert) {
+                circularByteBuffer.clear();
+                convert = false;
+            }
+            inputStream.close();
+        } catch (IOException e) {
+            logger.error("", e);
+            throw new DeactivateException();
+        }
+    }
+
+    public void work() {
+        if (!convert) {
+            try {
+                synchronized (this) {
+                    wait();
+                }
+            } catch (InterruptedException e) {
+                logger.error("", e);
+            }
+            return;
+        }
+        byte[] bytes = new byte[BYTES];
+        int read = 0;
+        try {
+            logger.debug("Writing input to process");
+            // Should be interrupted by stop()/exit()
+            while ((read = sourceInputStream.read(bytes)) > 0) {
+                /* Limit buffer size */
+                while (inputStream.available() > buffer) {
+                      int progress = (int) ((1 - (inputStream.available() - buffer) / (float) buffer) * 100);
+                    logger.trace("Waiting for buffer to empty: " + progress + "%");
+                    sleep(BUFFERING);
+                }
+                processOutputStream.write(bytes, 0, read);
+            }
+            processOutputStream.close();
+            logger.debug("Stopped writing input to process");
+            process.waitFor();
+            logger.debug("Process finished");
+        } catch (IOException e) {
+        } catch (InterruptedException e) {
+            logger.error("", e);
+        }
+        stop();
+    }
+
+    public synchronized InputStream getInputStream() {
+        if (!active()) {
+            start();
+            try {
+                wait();
+            } catch (InterruptedException e) {
+                logger.error("", e);
+            }
+        }
+        return inputStream;
+    }
+
+    public synchronized void setInputStream(InputStream inputStream) {
+        this.inputStream = inputStream;    
+    }
+
+    class BufferWorker extends Work {
+        public void work() {
+            byte[] bytes = new byte[BYTES];
+            int read = 0;
+            try {
+                OutputStream bufferOutputStream = circularByteBuffer.getOutputStream();
+                logger.debug("Start buffering process output");
+                while ((read = processInputStream.read(bytes, 0, BYTES)) > 0) {
+                    bufferOutputStream.write(bytes, 0, read);
+                }
+                logger.debug("Finished buffering process output");
+                bufferOutputStream.close();
+            } catch (IOException e) {}
+            stop();
+        }
+    }
+
+    public static void main(String[] args) {
+        Mp3 mp3 = new Mp3(new File("stream.mp3"), 128);
+        InputStream inputStream = mp3.getInputStream();
+
+        /* Play */
+        //Utils.play(inputStream);
+
+        /* Write to file */
+        Utils.write(inputStream, new File("output.mp3"));
+        mp3.exit();
+    }
+}