1 files changed, 411 insertions, 0 deletions

diff --git a/songdbj/javazoom/jl/converter/Converter.java b/songdbj/javazoom/jl/converter/Converter.java
new file mode 100644
index 0000000000..845082e626
--- /dev/null
+++ b/songdbj/javazoom/jl/converter/Converter.java
@@ -0,0 +1,411 @@
+/*
+ * 11/19/04 1.0 moved to LGPL.
+ * 12/12/99 Original verion. mdm@techie.com.
+ *-----------------------------------------------------------------------
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU Library General Public License as published
+ *   by the Free Software Foundation; either version 2 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 Library General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Library General Public
+ *   License along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *----------------------------------------------------------------------
+ */
+
+package javazoom.jl.converter;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+
+import javazoom.jl.decoder.Bitstream;
+import javazoom.jl.decoder.Decoder;
+import javazoom.jl.decoder.Header;
+import javazoom.jl.decoder.JavaLayerException;
+import javazoom.jl.decoder.Obuffer;
+
+/**
+ * The <code>Converter</code> class implements the conversion of
+ * an MPEG audio file to a .WAV file. To convert an MPEG audio stream,
+ * just create an instance of this class and call the convert()
+ * method, passing in the names of the input and output files. You can
+ * pass in optional <code>ProgressListener</code> and
+ * <code>Decoder.Params</code> objects also to customize the conversion.
+ *
+ * @author      MDM             12/12/99
+ * @since       0.0.7
+ */
+public class Converter
+{
+        /**
+         * Creates a new converter instance.
+         */
+        public Converter()
+        {
+        }
+
+        public synchronized void convert(String sourceName, String destName)
+                throws JavaLayerException
+        {
+                convert(sourceName, destName, null, null);
+        }
+
+        public synchronized void convert(String sourceName, String destName,
+                ProgressListener progressListener)
+                throws JavaLayerException
+        {
+                convert(sourceName, destName, progressListener, null);
+        }
+
+
+        public void convert(String sourceName, String destName,
+                ProgressListener progressListener, Decoder.Params decoderParams)
+                throws JavaLayerException
+        {
+                if (destName.length()==0)
+                        destName = null;
+                try {
+                        InputStream in = openInput(sourceName);
+                        convert(in, destName, progressListener, decoderParams);
+                        in.close();
+                } catch(IOException ioe) {
+                        throw new JavaLayerException(ioe.getLocalizedMessage(), ioe);
+                }
+        }
+
+        public synchronized void convert(InputStream sourceStream, String destName,
+                ProgressListener progressListener, Decoder.Params decoderParams)
+                throws JavaLayerException
+        {
+                if (progressListener==null)
+                        progressListener = PrintWriterProgressListener.newStdOut(
+                                        PrintWriterProgressListener.NO_DETAIL);
+                try {
+                        if (!(sourceStream instanceof BufferedInputStream))
+                                sourceStream = new BufferedInputStream(sourceStream);
+                        int frameCount = -1;
+                        if (sourceStream.markSupported()) {
+                                sourceStream.mark(-1);
+                                frameCount = countFrames(sourceStream);
+                                sourceStream.reset();
+                        }
+                        progressListener.converterUpdate(ProgressListener.UPDATE_FRAME_COUNT, frameCount, 0);
+
+
+                        Obuffer output = null;
+                        Decoder decoder = new Decoder(decoderParams);
+                        Bitstream stream = new Bitstream(sourceStream);
+
+                        if (frameCount==-1)
+                                frameCount = Integer.MAX_VALUE;
+
+                        int frame = 0;
+                        long startTime = System.currentTimeMillis();
+
+                        try
+                        {
+                                for (; frame<frameCount; frame++)
+                                {
+                                        try
+                                        {
+                                                Header header = stream.readFrame();
+                                                if (header==null)
+                                                        break;
+
+                                                progressListener.readFrame(frame, header);
+
+                                                if (output==null)
+                                                {
+                                                        // REVIEW: Incorrect functionality.
+                                                        // the decoder should provide decoded
+                                                        // frequency and channels output as it may differ from
+                                                        // the source (e.g. when downmixing stereo to mono.)
+                                                        int channels = (header.mode()==Header.SINGLE_CHANNEL) ? 1 : 2;
+                                                        int freq = header.frequency();
+                                                        output = new WaveFileObuffer(channels, freq, destName);
+                                                        decoder.setOutputBuffer(output);
+                                                }
+
+                                                Obuffer decoderOutput = decoder.decodeFrame(header, stream);
+
+                                                // REVIEW: the way the output buffer is set
+                                                // on the decoder is a bit dodgy. Even though
+                                                // this exception should never happen, we test to be sure.
+                                                if (decoderOutput!=output)
+                                                        throw new InternalError("Output buffers are different.");
+
+
+                                                progressListener.decodedFrame(frame, header, output);
+
+                                                stream.closeFrame();
+
+                                        }
+                                        catch (Exception ex)
+                                        {
+                                                boolean stop = !progressListener.converterException(ex);
+
+                                                if (stop)
+                                                {
+                                                        throw new JavaLayerException(ex.getLocalizedMessage(), ex);
+                                                }
+                                        }
+                                }
+
+                        }
+                        finally
+                        {
+
+                                if (output!=null)
+                                        output.close();
+                        }
+
+                        int time = (int)(System.currentTimeMillis()-startTime);
+                        progressListener.converterUpdate(ProgressListener.UPDATE_CONVERT_COMPLETE,
+                                time, frame);
+                }
+                catch (IOException ex)
+                {
+                        throw new JavaLayerException(ex.getLocalizedMessage(), ex);
+                }
+        }
+
+
+        protected int countFrames(InputStream in)
+        {
+                return -1;
+        }
+
+
+        protected InputStream openInput(String fileName)
+                throws IOException
+        {
+                // ensure name is abstract path name
+                File file = new File(fileName);
+                InputStream fileIn = new FileInputStream(file);
+                BufferedInputStream bufIn = new BufferedInputStream(fileIn);
+
+                return bufIn;
+        }
+
+
+        /**
+         * This interface is used by the Converter to provide
+         * notification of tasks being carried out by the converter,
+         * and to provide new information as it becomes available.
+         */
+
+        static public interface ProgressListener
+        {
+                public static final int UPDATE_FRAME_COUNT = 1;
+
+                /**
+                 * Conversion is complete. Param1 contains the time
+                 * to convert in milliseconds. Param2 contains the number
+                 * of MPEG audio frames converted.
+                 */
+                public static final int UPDATE_CONVERT_COMPLETE = 2;
+
+
+                /**
+                 * Notifies the listener that new information is available.
+                 *
+                 * @param updateID      Code indicating the information that has been
+                 *                                      updated.
+                 *
+                 * @param param1        Parameter whose value depends upon the update code.
+                 * @param param2        Parameter whose value depends upon the update code.
+                 *
+                 * The <code>updateID</code> parameter can take these values:
+                 *
+                 * UPDATE_FRAME_COUNT: param1 is the frame count, or -1 if not known.
+                 * UPDATE_CONVERT_COMPLETE: param1 is the conversion time, param2
+                 *              is the number of frames converted.
+                 */
+                public void converterUpdate(int updateID, int param1, int param2);
+
+                /**
+                 * If the converter wishes to make a first pass over the
+                 * audio frames, this is called as each frame is parsed.
+                 */
+                public void parsedFrame(int frameNo, Header header);
+
+                /**
+                 * This method is called after each frame has been read,
+                 * but before it has been decoded.
+                 *
+                 * @param frameNo       The 0-based sequence number of the frame.
+                 * @param header        The Header rerpesenting the frame just read.
+                 */
+                public void readFrame(int frameNo, Header header);
+
+                /**
+                 * This method is called after a frame has been decoded.
+                 *
+                 * @param frameNo       The 0-based sequence number of the frame.
+                 * @param header        The Header rerpesenting the frame just read.
+                 * @param o                     The Obuffer the deocded data was written to.
+                 */
+                public void decodedFrame(int frameNo, Header header, Obuffer o);
+
+                /**
+                 * Called when an exception is thrown during while converting
+                 * a frame.
+                 *
+                 * @param       t       The <code>Throwable</code> instance that
+                 *                              was thrown.
+                 *
+                 * @return <code>true</code> to continue processing, or false
+                 *                      to abort conversion.
+                 *
+                 * If this method returns <code>false</code>, the exception
+                 * is propagated to the caller of the convert() method. If
+                 * <code>true</code> is returned, the exception is silently
+                 * ignored and the converter moves onto the next frame.
+                 */
+                public boolean converterException(Throwable t);
+
+        }
+
+
+        /**
+         * Implementation of <code>ProgressListener</code> that writes
+         * notification text to a <code>PrintWriter</code>.
+         */
+        // REVIEW: i18n of text and order required.
+        static public class PrintWriterProgressListener implements ProgressListener
+        {
+                static public final int NO_DETAIL = 0;
+
+                /**
+                 * Level of detail typically expected of expert
+                 * users.
+                 */
+                static public final int EXPERT_DETAIL = 1;
+
+                /**
+                 * Verbose detail.
+                 */
+                static public final int VERBOSE_DETAIL = 2;
+
+                /**
+                 * Debug detail. All frame read notifications are shown.
+                 */
+                static public final int DEBUG_DETAIL = 7;
+
+                static public final int MAX_DETAIL = 10;
+
+                private PrintWriter pw;
+
+                private int detailLevel;
+
+                static public PrintWriterProgressListener newStdOut(int detail)
+                {
+                        return new PrintWriterProgressListener(
+                                new PrintWriter(System.out, true), detail);
+                }
+
+                public PrintWriterProgressListener(PrintWriter writer, int detailLevel)
+                {
+                        this.pw = writer;
+                        this.detailLevel = detailLevel;
+                }
+
+
+                public boolean isDetail(int detail)
+                {
+                        return (this.detailLevel >= detail);
+                }
+
+                public void converterUpdate(int updateID, int param1, int param2)
+                {
+                        if (isDetail(VERBOSE_DETAIL))
+                        {
+                                switch (updateID)
+                                {
+                                case UPDATE_CONVERT_COMPLETE:
+                                        // catch divide by zero errors.
+                                        if (param2==0)
+                                                param2 = 1;
+
+                                        pw.println();
+                                        pw.println("Converted "+param2+" frames in "+param1+" ms ("+
+                                                           (param1/param2)+" ms per frame.)");
+                                }
+                        }
+                }
+
+                public void parsedFrame(int frameNo, Header header)
+                {
+                        if ((frameNo==0) && isDetail(VERBOSE_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("File is a "+headerString);
+                        }
+                        else if (isDetail(MAX_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("Prased frame "+frameNo+": "+headerString);
+                        }
+                }
+
+                public void readFrame(int frameNo, Header header)
+                {
+                        if ((frameNo==0) && isDetail(VERBOSE_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("File is a "+headerString);
+                        }
+                        else if (isDetail(MAX_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("Read frame "+frameNo+": "+headerString);
+                        }
+                }
+
+                public void decodedFrame(int frameNo, Header header, Obuffer o)
+                {
+                        if (isDetail(MAX_DETAIL))
+                        {
+                                String headerString = header.toString();
+                                pw.println("Decoded frame "+frameNo+": "+headerString);
+                                pw.println("Output: "+o);
+                        }
+                        else if (isDetail(VERBOSE_DETAIL))
+                        {
+                                if (frameNo==0)
+                                {
+                                        pw.print("Converting.");
+                                        pw.flush();
+                                }
+
+                                if ((frameNo % 10)==0)
+                                {
+                                        pw.print('.');
+                                        pw.flush();
+                                }
+                        }
+                }
+
+                public boolean converterException(Throwable t)
+                {
+                        if (this.detailLevel>NO_DETAIL)
+                        {
+                                t.printStackTrace(pw);
+                                pw.flush();
+                        }
+                        return false;
+                }
+
+        }
+
+
+}
\ No newline at end of file