1 /*
2 * Copyright (c) 1999, 2018, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package com.sun.media.sound;
27
28 import java.applet.AudioClip;
29 import java.io.BufferedInputStream;
30 import java.io.ByteArrayOutputStream;
31 import java.io.IOException;
32 import java.io.InputStream;
33 import java.net.URL;
34 import java.net.URLConnection;
35
36 import javax.sound.midi.InvalidMidiDataException;
37 import javax.sound.midi.MetaEventListener;
38 import javax.sound.midi.MetaMessage;
39 import javax.sound.midi.MidiFileFormat;
40 import javax.sound.midi.MidiSystem;
41 import javax.sound.midi.MidiUnavailableException;
42 import javax.sound.midi.Sequence;
43 import javax.sound.midi.Sequencer;
44 import javax.sound.sampled.AudioFormat;
45 import javax.sound.sampled.AudioInputStream;
46 import javax.sound.sampled.AudioSystem;
47 import javax.sound.sampled.Clip;
48 import javax.sound.sampled.DataLine;
49 import javax.sound.sampled.LineEvent;
50 import javax.sound.sampled.LineListener;
51 import javax.sound.sampled.SourceDataLine;
52 import javax.sound.sampled.UnsupportedAudioFileException;
53
54 /**
55 * Java Sound audio clip;
56 *
57 * @author Arthur van Hoff, Kara Kytle, Jan Borgersen
58 * @author Florian Bomers
59 */
60 @SuppressWarnings("deprecation")
61 public final class JavaSoundAudioClip implements AudioClip, MetaEventListener, LineListener {
62
63 private static final boolean DEBUG = false;
64 private static final int BUFFER_SIZE = 16384; // number of bytes written each time to the source data line
65
66 private long lastPlayCall = 0;
67 private static final int MINIMUM_PLAY_DELAY = 30;
68
69 private byte loadedAudio[] = null;
70 private int loadedAudioByteLength = 0;
71 private AudioFormat loadedAudioFormat = null;
72
73 private AutoClosingClip clip = null;
74 private boolean clipLooping = false;
75
76 private DataPusher datapusher = null;
77
78 private Sequencer sequencer = null;
79 private Sequence sequence = null;
80 private boolean sequencerloop = false;
81 private volatile boolean success;
82
83 /**
84 * used for determining how many samples is the
85 * threshhold between playing as a Clip and streaming
86 * from the file.
87 *
88 * $$jb: 11.07.99: the engine has a limit of 1M
89 * samples to play as a Clip, so compare this number
90 * with the number of samples in the stream.
91 *
92 */
93 private static final long CLIP_THRESHOLD = 1048576;
94 //private final static long CLIP_THRESHOLD = 1;
95 private static final int STREAM_BUFFER_SIZE = 1024;
96
97 public static JavaSoundAudioClip create(final URLConnection uc) {
98 JavaSoundAudioClip clip = new JavaSoundAudioClip();
99 try {
100 clip.init(uc.getInputStream());
101 } catch (final Exception ignored) {
102 // AudioClip will be no-op if some exception will occurred
103 }
104 return clip;
105 }
106
107 public static JavaSoundAudioClip create(final URL url) {
108 JavaSoundAudioClip clip = new JavaSoundAudioClip();
109 try {
110 clip.init(url.openStream());
111 } catch (final Exception ignored) {
112 // AudioClip will be no-op if some exception will occurred
113 }
114 return clip;
115 }
116
117 private void init(InputStream in) throws IOException {
118 if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip.<init>");
119
120 BufferedInputStream bis = new BufferedInputStream(in, STREAM_BUFFER_SIZE);
121 bis.mark(STREAM_BUFFER_SIZE);
122 try {
123 AudioInputStream as = AudioSystem.getAudioInputStream(bis);
124 // load the stream data into memory
125 success = loadAudioData(as);
126
127 if (success) {
128 success = false;
129 if (loadedAudioByteLength < CLIP_THRESHOLD) {
130 success = createClip();
131 }
132 if (!success) {
133 success = createSourceDataLine();
134 }
135 }
136 } catch (UnsupportedAudioFileException e) {
137 // not an audio file
138 try {
139 MidiFileFormat mff = MidiSystem.getMidiFileFormat(bis);
140 success = createSequencer(bis);
141 } catch (InvalidMidiDataException e1) {
142 success = false;
143 }
144 }
145 }
146
147 @Override
148 public synchronized void play() {
149 if (!success) {
150 return;
151 }
152 startImpl(false);
153 }
154
155 @Override
156 public synchronized void loop() {
157 if (!success) {
158 return;
159 }
160 startImpl(true);
161 }
162
163 private synchronized void startImpl(boolean loop) {
164 // hack for some applets that call the start method very rapidly...
165 long currentTime = System.currentTimeMillis();
166 long diff = currentTime - lastPlayCall;
167 if (diff < MINIMUM_PLAY_DELAY) {
168 if (DEBUG || Printer.debug) Printer.debug("JavaSoundAudioClip.startImpl(loop="+loop+"): abort - too rapdly");
169 return;
170 }
171 lastPlayCall = currentTime;
172
173 if (DEBUG || Printer.debug) Printer.debug("JavaSoundAudioClip.startImpl(loop="+loop+")");
174 try {
175 if (clip != null) {
176 if (!clip.isOpen()) {
177 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip: clip.open()");
178 clip.open(loadedAudioFormat, loadedAudio, 0, loadedAudioByteLength);
179 } else {
180 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip: clip.flush()");
181 clip.flush();
182 if (loop != clipLooping) {
183 // need to stop in case the looped status changed
184 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip: clip.stop()");
185 clip.stop();
186 }
187 }
188 clip.setFramePosition(0);
189 if (loop) {
190 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip: clip.loop()");
191 clip.loop(Clip.LOOP_CONTINUOUSLY);
192 } else {
193 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip: clip.start()");
194 clip.start();
195 }
196 clipLooping = loop;
197 if (DEBUG || Printer.debug)Printer.debug("Clip should be playing/looping");
198
199 } else if (datapusher != null ) {
200 datapusher.start(loop);
201 if (DEBUG || Printer.debug)Printer.debug("Stream should be playing/looping");
202
203 } else if (sequencer != null) {
204 sequencerloop = loop;
205 if (sequencer.isRunning()) {
206 sequencer.setMicrosecondPosition(0);
207 }
208 if (!sequencer.isOpen()) {
209 try {
210 sequencer.open();
211 sequencer.setSequence(sequence);
212
213 } catch (InvalidMidiDataException e1) {
214 if (DEBUG || Printer.err)e1.printStackTrace();
215 } catch (MidiUnavailableException e2) {
216 if (DEBUG || Printer.err)e2.printStackTrace();
217 }
218 }
219 sequencer.addMetaEventListener(this);
220 try {
221 sequencer.start();
222 } catch (Exception e) {
223 if (DEBUG || Printer.err) e.printStackTrace();
224 }
225 if (DEBUG || Printer.debug)Printer.debug("Sequencer should be playing/looping");
226 }
227 } catch (Exception e) {
228 if (DEBUG || Printer.err)e.printStackTrace();
229 }
230 }
231
232 @Override
233 public synchronized void stop() {
234 if (!success) {
235 return;
236 }
237
238 if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip->stop()");
239 lastPlayCall = 0;
240
241 if (clip != null) {
242 try {
243 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip: clip.flush()");
244 clip.flush();
245 } catch (Exception e1) {
246 if (Printer.err) e1.printStackTrace();
247 }
248 try {
249 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip: clip.stop()");
250 clip.stop();
251 } catch (Exception e2) {
252 if (Printer.err) e2.printStackTrace();
253 }
254 if (DEBUG || Printer.debug)Printer.debug("Clip should be stopped");
255
256 } else if (datapusher != null) {
257 datapusher.stop();
258 if (DEBUG || Printer.debug)Printer.debug("Stream should be stopped");
259
260 } else if (sequencer != null) {
261 try {
262 sequencerloop = false;
263 sequencer.removeMetaEventListener(this);
264 sequencer.stop();
265 } catch (Exception e3) {
266 if (Printer.err) e3.printStackTrace();
267 }
268 try {
269 sequencer.close();
270 } catch (Exception e4) {
271 if (Printer.err) e4.printStackTrace();
272 }
273 if (DEBUG || Printer.debug)Printer.debug("Sequencer should be stopped");
274 }
275 }
276
277 // Event handlers (for debugging)
278
279 @Override
280 public synchronized void update(LineEvent event) {
281 if (DEBUG || Printer.debug) Printer.debug("line event received: "+event);
282 }
283
284 // handle MIDI track end meta events for looping
285
286 @Override
287 public synchronized void meta(MetaMessage message) {
288
289 if (DEBUG || Printer.debug)Printer.debug("META EVENT RECEIVED!!!!! ");
290
291 if( message.getType() == 47 ) {
292 if (sequencerloop){
293 //notifyAll();
294 sequencer.setMicrosecondPosition(0);
295 loop();
296 } else {
297 stop();
298 }
299 }
300 }
301
302 @Override
303 public String toString() {
304 return getClass().toString();
305 }
306
307 @Override
308 protected void finalize() {
309
310 if (clip != null) {
311 if (DEBUG || Printer.trace)Printer.trace("JavaSoundAudioClip.finalize: clip.close()");
312 clip.close();
313 }
314
315 //$$fb 2001-09-26: may improve situation related to bug #4302884
316 if (datapusher != null) {
317 datapusher.close();
318 }
319
320 if (sequencer != null) {
321 sequencer.close();
322 }
323 }
324
325 // FILE LOADING METHODS
326
327 private boolean loadAudioData(AudioInputStream as) throws IOException, UnsupportedAudioFileException {
328 if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip->openAsClip()");
329
330 // first possibly convert this stream to PCM
331 as = Toolkit.getPCMConvertedAudioInputStream(as);
332 if (as == null) {
333 return false;
334 }
335
336 loadedAudioFormat = as.getFormat();
337 long frameLen = as.getFrameLength();
338 int frameSize = loadedAudioFormat.getFrameSize();
339 long byteLen = AudioSystem.NOT_SPECIFIED;
340 if (frameLen != AudioSystem.NOT_SPECIFIED
341 && frameLen > 0
342 && frameSize != AudioSystem.NOT_SPECIFIED
343 && frameSize > 0) {
344 byteLen = frameLen * frameSize;
345 }
346 if (byteLen != AudioSystem.NOT_SPECIFIED) {
347 // if the stream length is known, it can be efficiently loaded into memory
348 readStream(as, byteLen);
349 } else {
350 // otherwise we use a ByteArrayOutputStream to load it into memory
351 readStream(as);
352 }
353
354 // if everything went fine, we have now the audio data in
355 // loadedAudio, and the byte length in loadedAudioByteLength
356 return true;
357 }
358
359 private void readStream(AudioInputStream as, long byteLen) throws IOException {
360 // arrays "only" max. 2GB
361 int intLen;
362 if (byteLen > 2147483647) {
363 intLen = 2147483647;
364 } else {
365 intLen = (int) byteLen;
366 }
367 loadedAudio = new byte[intLen];
368 loadedAudioByteLength = 0;
369
370 // this loop may throw an IOException
371 while (true) {
372 int bytesRead = as.read(loadedAudio, loadedAudioByteLength, intLen - loadedAudioByteLength);
373 if (bytesRead <= 0) {
374 as.close();
375 break;
376 }
377 loadedAudioByteLength += bytesRead;
378 }
379 }
380
381 private void readStream(AudioInputStream as) throws IOException {
382
383 DirectBAOS baos = new DirectBAOS();
384 byte buffer[] = new byte[16384];
385 int bytesRead = 0;
386 int totalBytesRead = 0;
387
388 // this loop may throw an IOException
389 while( true ) {
390 bytesRead = as.read(buffer, 0, buffer.length);
391 if (bytesRead <= 0) {
392 as.close();
393 break;
394 }
395 totalBytesRead += bytesRead;
396 baos.write(buffer, 0, bytesRead);
397 }
398 loadedAudio = baos.getInternalBuffer();
399 loadedAudioByteLength = totalBytesRead;
400 }
401
402 // METHODS FOR CREATING THE DEVICE
403
404 private boolean createClip() {
405
406 if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip.createClip()");
407
408 try {
409 DataLine.Info info = new DataLine.Info(Clip.class, loadedAudioFormat);
410 if (!(AudioSystem.isLineSupported(info)) ) {
411 if (DEBUG || Printer.err)Printer.err("Clip not supported: "+loadedAudioFormat);
412 // fail silently
413 return false;
414 }
415 Object line = AudioSystem.getLine(info);
416 if (!(line instanceof AutoClosingClip)) {
417 if (DEBUG || Printer.err)Printer.err("Clip is not auto closing!"+clip);
418 // fail -> will try with SourceDataLine
419 return false;
420 }
421 clip = (AutoClosingClip) line;
422 clip.setAutoClosing(true);
423 if (DEBUG || Printer.debug) clip.addLineListener(this);
424 } catch (Exception e) {
425 if (DEBUG || Printer.err)e.printStackTrace();
426 // fail silently
427 return false;
428 }
429
430 if (clip==null) {
431 // fail silently
432 return false;
433 }
434
435 if (DEBUG || Printer.debug)Printer.debug("Loaded clip.");
436 return true;
437 }
438
439 private boolean createSourceDataLine() {
440 if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip.createSourceDataLine()");
441 try {
442 DataLine.Info info = new DataLine.Info(SourceDataLine.class, loadedAudioFormat);
443 if (!(AudioSystem.isLineSupported(info)) ) {
444 if (DEBUG || Printer.err)Printer.err("Line not supported: "+loadedAudioFormat);
445 // fail silently
446 return false;
447 }
448 SourceDataLine source = (SourceDataLine) AudioSystem.getLine(info);
449 datapusher = new DataPusher(source, loadedAudioFormat, loadedAudio, loadedAudioByteLength);
450 } catch (Exception e) {
451 if (DEBUG || Printer.err)e.printStackTrace();
452 // fail silently
453 return false;
454 }
455
456 if (datapusher==null) {
457 // fail silently
458 return false;
459 }
460
461 if (DEBUG || Printer.debug)Printer.debug("Created SourceDataLine.");
462 return true;
463 }
464
465 private boolean createSequencer(BufferedInputStream in) throws IOException {
466
467 if (DEBUG || Printer.debug)Printer.debug("JavaSoundAudioClip.createSequencer()");
468
469 // get the sequencer
470 try {
471 sequencer = MidiSystem.getSequencer( );
472 } catch(MidiUnavailableException me) {
473 if (DEBUG || Printer.err)me.printStackTrace();
474 return false;
475 }
476 if (sequencer==null) {
477 return false;
478 }
479
480 try {
481 sequence = MidiSystem.getSequence(in);
482 if (sequence == null) {
483 return false;
484 }
485 } catch (InvalidMidiDataException e) {
486 if (DEBUG || Printer.err)e.printStackTrace();
487 return false;
488 }
489
490 if (DEBUG || Printer.debug)Printer.debug("Created Sequencer.");
491 return true;
492 }
493
494 /*
495 * private inner class representing a ByteArrayOutputStream
496 * which allows retrieval of the internal array
497 */
498 private static class DirectBAOS extends ByteArrayOutputStream {
499 DirectBAOS() {
500 super();
501 }
502
503 public byte[] getInternalBuffer() {
504 return buf;
505 }
506
507 } // class DirectBAOS
508 }