← Back to branch summary

~gryle-devel/gryle/trunk-deleted

« back to all changes in this revision

Viewing changes to src/javazoom/jl/player/PlayerApplet.java

  • Committer: Chris Lamb
  • Date: 2007-01-13 22:14:47 UTC
  • mfrom: (1.2.4 gryle)
  • mto: (1.2.6 gryle)
  • mto: This revision was merged to the branch mainline in revision 9.
  • Revision ID: csueaj@viglab-29-20070113221447-9rl7yytjuzuibi1g
 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/javazoom/jl/player/PlayerApplet.java
 
1
/*
 
2
 * 11/19/04             1.0 moved to LGPL.
 
3
 * 29/01/00             Initial version. mdm@techie.com
 
4
 *-----------------------------------------------------------------------
 
5
 *   This program is free software; you can redistribute it and/or modify
 
6
 *   it under the terms of the GNU Library General Public License as published
 
7
 *   by the Free Software Foundation; either version 2 of the License, or
 
8
 *   (at your option) any later version.
 
9
 *
 
10
 *   This program is distributed in the hope that it will be useful,
 
11
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 *   GNU Library General Public License for more details.
 
14
 *
 
15
 *   You should have received a copy of the GNU Library General Public
 
16
 *   License along with this program; if not, write to the Free Software
 
17
 *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
18
 *----------------------------------------------------------------------
 
19
 */
 
20
 
 
21
package javazoom.jl.player;
 
22
 
 
23
import java.applet.Applet;
 
24
import java.io.IOException;
 
25
import java.io.InputStream;
 
26
import java.net.URL;
 
27
 
 
28
import javazoom.jl.decoder.JavaLayerException;
 
29
 
 
30
/**
 
31
 * A simple applet that plays an MPEG audio file. The URL (relative to the
 
32
 * document base) is passed as the "audioURL" parameter.
 
33
 * 
 
34
 * @author Mat McGowan
 
35
 * @since 0.0.8
 
36
 */
 
37
public class PlayerApplet extends Applet implements Runnable {
 
38
        static public final String AUDIO_PARAMETER = "audioURL";
 
39
 
 
40
        /**
 
41
         * The Player used to play the MPEG audio file.
 
42
         */
 
43
        private Player player = null;
 
44
 
 
45
        /**
 
46
         * The thread that runs the player.
 
47
         */
 
48
        private Thread playerThread = null;
 
49
 
 
50
        private String fileName = null;
 
51
 
 
52
        /**
 
53
         * Retrieves the <code>AudioDevice</code> instance that will be used to
 
54
         * sound the audio data.
 
55
         * 
 
56
         * @return an audio device instance that will be used to sound the audio
 
57
         *         stream.
 
58
         */
 
59
        protected AudioDevice getAudioDevice() throws JavaLayerException {
 
60
                return FactoryRegistry.systemRegistry().createAudioDevice();
 
61
        }
 
62
 
 
63
        /**
 
64
         * Retrieves the InputStream that provides the MPEG audio stream data.
 
65
         * 
 
66
         * @return an InputStream from which the MPEG audio data is read, or null if
 
67
         *         an error occurs.
 
68
         */
 
69
        protected InputStream getAudioStream() {
 
70
                InputStream in = null;
 
71
 
 
72
                try {
 
73
                        URL url = getAudioURL();
 
74
                        if (url != null)
 
75
                                in = url.openStream();
 
76
                } catch (IOException ex) {
 
77
                        System.err.println(ex);
 
78
                }
 
79
                return in;
 
80
        }
 
81
 
 
82
        protected String getAudioFileName() {
 
83
                String urlString = fileName;
 
84
                if (urlString == null) {
 
85
                        urlString = getParameter(AUDIO_PARAMETER);
 
86
                }
 
87
                return urlString;
 
88
        }
 
89
 
 
90
        protected URL getAudioURL() {
 
91
                String urlString = getAudioFileName();
 
92
                URL url = null;
 
93
                if (urlString != null) {
 
94
                        try {
 
95
                                url = new URL(getDocumentBase(), urlString);
 
96
                        } catch (Exception ex) {
 
97
                                System.err.println(ex);
 
98
                        }
 
99
                }
 
100
                return url;
 
101
        }
 
102
 
 
103
        /**
 
104
         * Sets the URL of the audio stream to play.
 
105
         */
 
106
        public void setFileName(String name) {
 
107
                fileName = name;
 
108
        }
 
109
 
 
110
        public String getFileName() {
 
111
                return fileName;
 
112
        }
 
113
 
 
114
        /**
 
115
         * Stops the audio player. If the player is already stopped this method is a
 
116
         * no-op.
 
117
         */
 
118
        protected void stopPlayer() throws JavaLayerException {
 
119
                if (player != null) {
 
120
                        player.close();
 
121
                        player = null;
 
122
                        playerThread = null;
 
123
                }
 
124
        }
 
125
 
 
126
        /**
 
127
         * Decompresses audio data from an InputStream and plays it back through an
 
128
         * AudioDevice. The playback is run on a newly created thread.
 
129
         * 
 
130
         * @param in
 
131
         *            The InputStream that provides the MPEG audio data.
 
132
         * @param dev
 
133
         *            The AudioDevice to use to sound the decompressed data.
 
134
         * 
 
135
         * @throws JavaLayerException
 
136
         *             if there was a problem decoding or playing the audio data.
 
137
         */
 
138
        protected void play(InputStream in, AudioDevice dev)
 
139
                        throws JavaLayerException {
 
140
                stopPlayer();
 
141
 
 
142
                if (in != null && dev != null) {
 
143
                        player = new Player(in, dev);
 
144
                        playerThread = createPlayerThread();
 
145
                        playerThread.start();
 
146
                }
 
147
        }
 
148
 
 
149
        /**
 
150
         * Creates a new thread used to run the audio player.
 
151
         * 
 
152
         * @return A new Thread that, once started, runs the audio player.
 
153
         */
 
154
        protected Thread createPlayerThread() {
 
155
                return new Thread(this, "Audio player thread");
 
156
        }
 
157
 
 
158
        /**
 
159
         * Initializes this applet.
 
160
         */
 
161
        public void init() {
 
162
        }
 
163
 
 
164
        /**
 
165
         * Starts this applet. An input stream and audio device are created and
 
166
         * passed to the play() method.
 
167
         */
 
168
        public void start() {
 
169
                String name = getAudioFileName();
 
170
                try {
 
171
                        InputStream in = getAudioStream();
 
172
                        AudioDevice dev = getAudioDevice();
 
173
                        play(in, dev);
 
174
                } catch (JavaLayerException ex) {
 
175
                        synchronized (System.err) {
 
176
                                System.err.println("Unable to play " + name);
 
177
                                ex.printStackTrace(System.err);
 
178
                        }
 
179
                }
 
180
        }
 
181
 
 
182
        /**
 
183
         * Stops this applet. If audio is currently playing, it is stopped.
 
184
         */
 
185
        public void stop() {
 
186
                try {
 
187
                        stopPlayer();
 
188
                } catch (JavaLayerException ex) {
 
189
                        System.err.println(ex);
 
190
                }
 
191
        }
 
192
 
 
193
        public void destroy() {
 
194
        }
 
195
 
 
196
        /**
 
197
         * The run method for the audio player thread. Simply calls play() on the
 
198
         * player to play the entire stream.
 
199
         */
 
200
        public void run() {
 
201
                if (player != null) {
 
202
                        try {
 
203
                                player.play();
 
204
                        } catch (JavaLayerException ex) {
 
205
                                System.err.println("Problem playing audio: " + ex);
 
206
                        }
 
207
                }
 
208
        }
 
209
}