Logo Search packages:      
Sourcecode: libjlayer-java version File versions  Download package

Converter.java

/*
 * 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
 */
00047 public class Converter
{
      /**
       * Creates a new converter instance.
       */
00052       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.
       */

00206       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.
             */
00215             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.
00284       static public class PrintWriterProgressListener implements ProgressListener
      {
            static public final int NO_DETAIL = 0;

            /**
             * Level of detail typically expected of expert
             * users.
             */
00292             static public final int EXPERT_DETAIL = 1;

            /**
             * Verbose detail.
             */
00297             static public final int VERBOSE_DETAIL = 2;

            /**
             * Debug detail. All frame read notifications are shown.
             */
00302             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);
            }

00328             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.)");
                        }
                  }
            }

00346             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);
                  }
            }

00360             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);
                  }
            }

00374             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();
                        }
                  }
            }

00398             public boolean converterException(Throwable t)
            {
                  if (this.detailLevel>NO_DETAIL)
                  {
                        t.printStackTrace(pw);
                        pw.flush();
                  }
                  return false;
            }

      }


}

Generated by  Doxygen 1.6.0   Back to index