| /* AudioPlayerSample.java -- Simple Java Audio Player |
| Copyright (C) 2007 Free Software Foundation, Inc. |
| |
| This file is part of GNU Classpath. |
| |
| GNU Classpath 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 2, or (at your option) |
| any later version. |
| |
| GNU Classpath 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 GNU Classpath; see the file COPYING. If not, write to the |
| Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA |
| 02110-1301 USA. |
| |
| Linking this library statically or dynamically with other modules is |
| making a combined work based on this library. Thus, the terms and |
| conditions of the GNU General Public License cover the whole |
| combination. |
| |
| As a special exception, the copyright holders of this library give you |
| permission to link this library with independent modules to produce an |
| executable, regardless of the license terms of these independent |
| modules, and to copy and distribute the resulting executable under |
| terms of your choice, provided that you also meet, for each linked |
| independent module, the terms and conditions of the license of that |
| module. An independent module is a module which is not derived from |
| or based on this library. If you modify this library, you may extend |
| this exception to your version of the library, but you are not |
| obligated to do so. If you do not wish to do so, delete this |
| exception statement from your version. */ |
| package gnu.classpath.examples.sound; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.Map; |
| |
| import javax.sound.sampled.AudioFormat; |
| import javax.sound.sampled.AudioInputStream; |
| import javax.sound.sampled.AudioSystem; |
| import javax.sound.sampled.DataLine; |
| import javax.sound.sampled.LineUnavailableException; |
| import javax.sound.sampled.SourceDataLine; |
| import javax.sound.sampled.UnsupportedAudioFileException; |
| |
| /** |
| * A simple demo to show the use of the Java Sound API. |
| * It plays the given file (up to the end, so don't pass the 26 minutes long |
| * Pink Floyd's Echoes unless you really want!!). |
| * |
| * See: http://jsresources.org/examples/SimpleAudioPlayer.java.html |
| * |
| * @author Mario Torre <neugens@limasoftware.net> |
| */ |
| public class AudioPlayerSample |
| { |
| private static final int EXTERNAL_BUFFER_SIZE = 128000; |
| |
| /** |
| * @param args |
| */ |
| public static void main(String[] args) |
| { |
| if (args.length < 1) |
| { |
| System.out.println("Radio Classpath -: Usage: " + |
| "AudioPlayerSample [file]"); |
| return; |
| } |
| |
| String file = args[0]; |
| |
| System.out.println("Welcome to Radio Classpath, only great music for you!"); |
| System.out.println("Today's DJ Tap The WaterDroplet"); |
| |
| // now create the AudioInputStream |
| AudioInputStream audioInputStream = null; |
| try |
| { |
| audioInputStream = AudioSystem.getAudioInputStream(new File(file)); |
| } |
| catch (UnsupportedAudioFileException e) |
| { |
| // This happen when the subsystem is unable to parse the kind of |
| // audio file we are submitting |
| // See the README for supported audio file types under Classpath |
| // for the version you are using. |
| e.printStackTrace(); |
| return; |
| } |
| catch (IOException e) |
| { |
| e.printStackTrace(); |
| return; |
| } |
| |
| // get informations about the kind of file we are about to play |
| AudioFormat audioFormat = audioInputStream.getFormat(); |
| |
| System.out.println("Playing file: " + file); |
| System.out.println("format: " + audioFormat.toString()); |
| |
| System.out.print("Additional properties: "); |
| |
| // now, we try to get all the properties we have in this AudioFormat |
| // and display them |
| Map<String, Object> properties = audioFormat.properties(); |
| if (properties.size() < 0) |
| { |
| System.out.println("none"); |
| } |
| else |
| { |
| System.out.println("found #" + properties.size() + " properties"); |
| for (String key : properties.keySet()) |
| { |
| System.out.println(key + ": " + properties.get(key)); |
| } |
| } |
| |
| // let's setup things for playing |
| // first, we require a Line. As we are doing playing, we will ask for a |
| // SourceDataLine |
| SourceDataLine line = null; |
| |
| // To get the source line, we first need to build an Info object |
| // this is done in one line: |
| DataLine.Info info = new DataLine.Info(SourceDataLine.class, audioFormat); |
| |
| System.out.println("searching line..."); |
| |
| // usually, if a backend can parse a file type, it can also |
| // create a line to handle it, but that's not guaranteed |
| // so we need to take care and to handle a possible |
| // LineUnavailableException |
| try |
| { |
| line = (SourceDataLine) AudioSystem.getLine(info); |
| |
| System.out.println("line found, opening..."); |
| |
| // once created, a line must be opened to let data flow |
| // though it. |
| line.open(audioFormat); |
| } |
| catch (LineUnavailableException e) |
| { |
| // in a real application you should signal that in a kindly way to |
| // your users |
| e.printStackTrace(); |
| return; |
| } |
| catch (Exception e) |
| { |
| e.printStackTrace(); |
| return; |
| } |
| |
| // an open line pass data to the backend only when it is in |
| // a state called "started" ("playing" or "play" in some other |
| // framework) |
| System.out.print("starting line... "); |
| |
| line.start(); |
| System.out.println("done"); |
| |
| // now we can start reading data from the AudioStream and writing |
| // data to the pipeline. The Java Sound API is rather low level |
| // so let you pass up to one byte of data at a time |
| // (with some constraints, refer to the API documentation to know more) |
| // We will do some buffering. You may want to check the frame size |
| // to allow a better buffering, also. |
| |
| System.out.println("now playing..."); |
| |
| int nBytesRead = 0; |
| byte[] abData = new byte[EXTERNAL_BUFFER_SIZE]; |
| while (nBytesRead != - 1) |
| { |
| try |
| { |
| nBytesRead = audioInputStream.read(abData, 0, abData.length); |
| } |
| catch (IOException e) |
| { |
| e.printStackTrace(); |
| } |
| |
| if (nBytesRead >= 0) |
| { |
| // this method returns the number of bytes actuall written |
| // to the line. You may want to use this number to check |
| // for events, display the current position (give also a |
| // look to the API for other ways of doing that) etc.. |
| line.write(abData, 0, nBytesRead); |
| } |
| } |
| |
| System.out.print("stream finished, draining line... "); |
| |
| // call this method to ensure that all the data in the internal buffer |
| // reach the audio backend, otherwise your application will |
| // cut the last frames of audio data (and users will not enjoy the last |
| // seconds of their precious music) |
| line.drain(); |
| |
| // Once done, we can close the line. Note that a line, once closed |
| // may not be reopened (depends on the backend, in some cases a "reopen", |
| // if allowed, really opens a new line, reallocating all the resources) |
| |
| System.out.println("line drained, now exiting"); |
| line.close(); |
| |
| System.out.println("We hope you enjoyed Radio Classpath!"); |
| } |
| |
| } |