
MP3JavaSoundAudioPlayer.java


/*

 * Created on 2004/10/03

 * Author aki@www.xucker.jpn.org

 * License Apache2.0 or Common Public License

 */

package org.jpn.xucker.mp3;

import java.util.Map;



import org.apache.commons.logging.Log;

import org.apache.commons.logging.LogFactory;

import org.jpn.xucker.commons.audio.JavaSoundAudioPlayer;

import org.jpn.xucker.repeatrecorder.RepeatRecorder;

import org.tritonus.share.sampled.file.TAudioFileFormat;



import java.io.File;

import java.io.FileInputStream;

import java.io.InputStream;



import javax.sound.sampled.AudioFileFormat;

import javax.sound.sampled.AudioFormat;

import javax.sound.sampled.AudioInputStream;



import javazoom.jl.decoder.JavaLayerException;

import javazoom.jl.player.advanced.AdvancedPlayer;

import javazoom.jl.player.advanced.PlaybackEvent;

import javazoom.jl.player.advanced.PlaybackListener;

import javazoom.spi.mpeg.sampled.file.MpegAudioFileFormat;

import javazoom.spi.mpeg.sampled.file.MpegAudioFileReader;





/**

 * 

 *

 */

public class MP3JavaSoundAudioPlayer extends JavaSoundAudioPlayer{



    

    public static Log log=LogFactory.getLog(MP3JavaSoundAudioPlayer.class);

    private MpegAudioFileReader mpegAudioFileReader=new MpegAudioFileReader();

    private AdvancedPlayer advancedPlayer;

    

    private StopMonitor stopMonitor=new StopMonitor();



    public class DummyPlayBackListener extends PlaybackListener{

        public void playbackStarted(PlaybackEvent evt){

            log.debug("playback start");

            }

      public void playbackFinished(PlaybackEvent evt){

          log.debug("playback stop");

          }

    }

   

    /* (non-Javadoc)

     * @see org.jpn.xucker.commons.audio.sp.AudioInputStreamPlayer#play(javax.sound.sampled.AudioInputStream)

     */

    public void play(InputStream stream) {

       play(stream,0,0);

    }

    



    public class StopMonitor extends Thread{

        public void run(){

            log.debug("start stopmonitor");

            while(!stopper.isStopped()){

            try {

                Thread.sleep(10);

            } catch (InterruptedException e) {

                // TODO Auto-generated catch block

                e.printStackTrace();

            }   

            }

            if(advancedPlayer!=null){

                log.debug("call stopped");

                try{

                advancedPlayer.stop();

                }catch(Exception e){

                    e.printStackTrace();

                }

            }

        }

    }

    

    

   

    public void play(File file,long startmillisecond,long endmillisecond) {

      

        stopMonitor.start();

        

        try{

            boolean isLimit=true;

            if(endmillisecond==0){

                isLimit=false;

            }

            

            AudioInputStream audioInputStream=null;

            AudioInputStream in=mpegAudioFileReader.getAudioInputStream(new FileInputStream(file));

            

            

            AudioFormat baseFormat = in.getFormat();

            AudioFileFormat baseFileFormat=mpegAudioFileReader.getAudioFileFormat(in);

          

            long skipbyte=0;

            double fps=0;

            int bps=0;

            if (baseFileFormat instanceof MpegAudioFileFormat)

            {

                Map props = ((TAudioFileFormat)baseFileFormat).properties();

                Object[] obj=props.keySet().toArray();

                for(int i=0;i<obj.length;i++){

                    log.trace(obj[i]+"="+props.get(obj[i]).toString());

                    //System.out.println(obj[i]+"="+props.get(obj[i]).toString());

                }

                bps=Integer.parseInt(props.get("mp3.bitrate.nominal.bps").toString());

                fps=Double.parseDouble(props.get("mp3.framerate.fps").toString());

                skipbyte=startmillisecond/1000*(bps/8);

                

             

            }

            in.close();

            

            //System.out.println(skipbyte);

            //stream.skip(skip-32*1024);

            

            

            try {

                int skip1=(int)(fps*startmillisecond/1000);

                int skip2=(int)(fps*endmillisecond/1000);

                FileInputStream fi=new FileInputStream(file);

                fi.skip(bps/8*startmillisecond/1000);

                advancedPlayer = new AdvancedPlayer(fi);

                advancedPlayer.setPlayBackListener(new DummyPlayBackListener());

                advancedPlayer.play(skip2-skip1);

                

                fi.close();

                

            } catch (JavaLayerException e1) {

                // TODO Auto-generated catch block

                e1.printStackTrace();

            }finally{

                log.debug("stopped");

                stopper.setStopped(true);

            }

           

            

            /*

            if (baseFileFormat instanceof TAudioFileFormat)

            {

                Map props = ((TAudioFileFormat)baseFileFormat).properties();

                Object[] obj=props.keySet().toArray();

                for(int i=0;i<obj.length;i++){

                    System.out.println(obj[i]+"="+props.get(obj[i]).toString());

                }

                long bps=Long.parseLong(props.get("ogg.bitrate.nominal.bps").toString());

                skip=startmillisecond/1000*(bps/8);

                System.out.println("skip:"+skip);

               

            }*/

            /*

            AudioFormat  decodedFormat = new AudioFormat(

                    AudioFormat.Encoding.PCM_SIGNED,

                    baseFormat.getSampleRate(),

                    16,

                    baseFormat.getChannels(),

                    baseFormat.getChannels() * 2,

                    baseFormat.getSampleRate(),

                    false);

            

            

            

          

            

            MpegFormatConversionProvider provider=new javazoom.spi.mpeg.sampled.convert.MpegFormatConversionProvider();

            //audioInputStream=AudioSystem.getAudioInputStream(decodedFormat,in);

            audioInputStream=provider.getAudioInputStream(decodedFormat,in);

            //AudioInputStream inputStream =

            // AudioSystem.getAudioInputStream(audioFile);

             AudioFormat format =audioInputStream.getFormat();

             

             long startByte=countByteAt(format,startmillisecond);

             long endByte=countByteAt(format,endmillisecond);

             long playByte=endByte-startByte;

             

           log.debug("s="+startByte+",e="+endByte+" p="+playByte);

           

           DataLine.Info info = new DataLine.Info(SourceDataLine.class,format);

           SourceDataLine line = (SourceDataLine) AudioSystem.getLine(info);

           line.open(format);

           line.start();

           

           //in.skip(384000*10);

           

          // audioInputStream.skip(727);

           //audioInputStream.skip(skip);

           //skip is bad.

           

           

           //audioInputStream.skip(skip);  //mp3 bitrate!!! skip

           */

           /*

           long skippedbyte=0;

           byte[] skipper=new byte[1024];

           long start=System.currentTimeMillis();

           while(true){

          // while(skippedbyte<startByte){

               int readBytes = audioInputStream.read(skipper, 0, skipper.length);

               if(readBytes==-1){

                   break;

               }else{

               skippedbyte+=readBytes;

               }

               

           }

           System.out.println("skipall:"+(start-System.currentTimeMillis()));

           System.out.println("skippedbyte:"+skippedbyte);

           */

           

           /*

            int readbytes = 0;

            byte[] bytedata = new byte[buffer];

            long readed=0;

            

            

            while (readbytes != -1) {

                if(stopper!=null && stopper.isStopped()==true){

                    break;

                }

                

             

             readbytes = audioInputStream.read(bytedata, 0, bytedata.length);

             log.trace("read:"+readbytes);

              if (readbytes > 0) {

                //int writeBytes =

                  if(isLimit){

                  if(readed+readbytes<playByte){

                 // System.out.println(bytedata[0]);

                  try{

                      log.trace(""+readbytes);

                      line.write(bytedata, 0,readbytes); // sometime err?

                 // line.write(bytedata, 0, readBytes.); //?

                  

                  }catch(Exception e){e.printStackTrace();};

                  //line.write(bytedata, 0,bytedata.length); //?

                  }else{

                  log.trace("break;");

                  line.write(bytedata, 0, Math.min((int)(playByte-readed),readbytes));

                  break;

                  }

                  }else{//for normal play.

                      line.write(bytedata, 0,readbytes);

                  }

                  

                  readed+=readbytes;

                  log.trace("readedByte:"+readed);

              }

            }

            

            //System.out.println(readedByte);

            

            */

            /*

            //mpeg2

            int readData;

            long readSize=0;

            

            ByteArrayOutputStream bout=new ByteArrayOutputStream();

            while ((readData=audioInputStream.read()) != -1) {

                if(stopper!=null && stopper.isStopped()==true){

                    break;

                }

                

                bout.write(readData);

                readSize++;

                if(readSize>playByte){

                    break;

                }

            }

            

            ByteArrayInputStream binput=new ByteArrayInputStream(bout.toByteArray());

            byte[] buffer=new byte[1024];

            

            while(true){

                int read=binput.read(buffer);

                if(read==-1){

                    break;

                }

                line.write(buffer,0,read); //?

            }

             

                  */

              

            /*

            

            line.drain();

            line.close();

            

            audioInputStream.close();

            

            */

          }catch(Exception e){

              e.printStackTrace();

          }

    }

}