feat(jdk8): move files to new folder to avoid resources compiled.

jdkSrc/jdk8/sun/audio/AudioDevice.java

@@ -0,0 +1,425 @@
+/*
+ * Copyright (c) 1999, 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.  Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code 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
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+package sun.audio;
+
+import java.util.Hashtable;
+import java.util.Vector;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.BufferedInputStream;
+
+import javax.sound.sampled.*;
+import javax.sound.midi.*;
+import com.sun.media.sound.DataPusher;
+import com.sun.media.sound.Toolkit;
+
+/**
+ * This class provides an interface to the Headspace Audio engine through
+ * the Java Sound API.
+ *
+ * This class emulates systems with multiple audio channels, mixing
+ * multiple streams for the workstation's single-channel device.
+ *
+ * @see AudioData
+ * @see AudioDataStream
+ * @see AudioStream
+ * @see AudioStreamSequence
+ * @see ContinuousAudioDataStream
+ * @author David Rivas
+ * @author Kara Kytle
+ * @author Jan Borgersen
+ * @author Florian Bomers
+ */
+
+public final class AudioDevice {
+
+    private boolean DEBUG = false  /*true*/ ;
+
+    /** Hashtable of audio clips / input streams. */
+    private Hashtable clipStreams;
+
+    private Vector infos;
+
+    /** Are we currently playing audio? */
+    private boolean playing = false;
+
+    /** Handle to the JS audio mixer. */
+    private Mixer mixer = null;
+
+
+
+    /**
+     * The default audio player. This audio player is initialized
+     * automatically.
+     */
+    public static final AudioDevice device = new AudioDevice();
+
+    /**
+     * Create an AudioDevice instance.
+     */
+    private AudioDevice() {
+
+        clipStreams = new Hashtable();
+        infos = new Vector();
+    }
+
+
+    private synchronized void startSampled( AudioInputStream as,
+                                            InputStream in ) throws UnsupportedAudioFileException,
+                                  LineUnavailableException {
+
+        Info info = null;
+        DataPusher datapusher = null;
+        DataLine.Info lineinfo = null;
+        SourceDataLine sourcedataline = null;
+
+        // if ALAW or ULAW, we must convert....
+        as = Toolkit.getPCMConvertedAudioInputStream(as);
+
+        if( as==null ) {
+            // could not convert
+            return;
+        }
+
+        lineinfo = new DataLine.Info(SourceDataLine.class,
+                                     as.getFormat());
+        if( !(AudioSystem.isLineSupported(lineinfo))) {
+            return;
+        }
+        sourcedataline = (SourceDataLine)AudioSystem.getLine(lineinfo);
+        datapusher = new DataPusher(sourcedataline, as);
+
+        info = new Info( null, in, datapusher );
+        infos.addElement( info );
+
+        datapusher.start();
+    }
+
+    private synchronized void startMidi( InputStream bis,
+                                         InputStream in ) throws InvalidMidiDataException,
+                                  MidiUnavailableException  {
+
+        Sequencer sequencer = null;
+        Info info = null;
+
+        sequencer = MidiSystem.getSequencer( );
+        sequencer.open();
+        try {
+            sequencer.setSequence( bis );
+        } catch( IOException e ) {
+            throw new InvalidMidiDataException( e.getMessage() );
+        }
+
+        info = new Info( sequencer, in, null );
+
+        infos.addElement( info );
+
+        // fix for bug 4302884: Audio device is not released when AudioClip stops
+        sequencer.addMetaEventListener(info);
+
+        sequencer.start();
+
+    }
+
+
+
+    /**
+     *  Open an audio channel.
+     */
+    public synchronized void openChannel(InputStream in) {
+
+
+        if(DEBUG) {
+            System.out.println("AudioDevice: openChannel");
+            System.out.println("input stream =" + in);
+        }
+
+        Info info = null;
+
+        // is this already playing?  if so, then just return
+        for(int i=0; i<infos.size(); i++) {
+            info = (AudioDevice.Info)infos.elementAt(i);
+            if( info.in == in ) {
+
+                return;
+            }
+        }
+
+
+        AudioInputStream as = null;
+
+        if( in instanceof AudioStream ) {
+
+            if ( ((AudioStream)in).midiformat != null ) {
+
+                // it's a midi file
+                try {
+                    startMidi( ((AudioStream)in).stream, in );
+                } catch (Exception e) {
+                    return;
+                }
+
+
+            } else if( ((AudioStream)in).ais != null ) {
+
+                // it's sampled audio
+                try {
+                    startSampled( ((AudioStream)in).ais, in );
+                } catch (Exception e) {
+                    return;
+                }
+
+            }
+        } else if (in instanceof AudioDataStream ) {
+            if (in instanceof ContinuousAudioDataStream) {
+                try {
+                    AudioInputStream ais = new AudioInputStream(in,
+                                                                ((AudioDataStream)in).getAudioData().format,
+                                                                AudioSystem.NOT_SPECIFIED);
+                    startSampled(ais, in );
+                } catch (Exception e) {
+                    return;
+                }
+            }
+            else {
+                try {
+                    AudioInputStream ais = new AudioInputStream(in,
+                                                                ((AudioDataStream)in).getAudioData().format,
+                                                                ((AudioDataStream)in).getAudioData().buffer.length);
+                    startSampled(ais, in );
+                } catch (Exception e) {
+                    return;
+                }
+            }
+        } else {
+            BufferedInputStream bis = new BufferedInputStream( in, 1024 );
+
+            try {
+
+                try {
+                    as = AudioSystem.getAudioInputStream(bis);
+                } catch(IOException ioe) {
+                    return;
+                }
+
+                startSampled( as, in );
+
+            } catch( UnsupportedAudioFileException e ) {
+
+                try {
+                    try {
+                        MidiFileFormat mff =
+                            MidiSystem.getMidiFileFormat( bis );
+                    } catch(IOException ioe1) {
+                        return;
+                    }
+
+                    startMidi( bis, in );
+
+
+                } catch( InvalidMidiDataException e1 ) {
+
+                    // $$jb:08.01.99: adding this section to make some of our other
+                    // legacy classes work.....
+                    // not MIDI either, special case handling for all others
+
+                    AudioFormat defformat = new AudioFormat( AudioFormat.Encoding.ULAW,
+                                                             8000, 8, 1, 1, 8000, true );
+                    try {
+                        AudioInputStream defaif = new AudioInputStream( bis,
+                                                                        defformat, AudioSystem.NOT_SPECIFIED);
+                        startSampled( defaif, in );
+                    } catch (UnsupportedAudioFileException es) {
+                        return;
+                    } catch (LineUnavailableException es2) {
+                        return;
+                    }
+
+                } catch( MidiUnavailableException e2 ) {
+
+                    // could not open sequence
+                    return;
+                }
+
+            } catch( LineUnavailableException e ) {
+
+                return;
+            }
+        }
+
+        // don't forget adjust for a new stream.
+        notify();
+    }
+
+
+    /**
+     *  Close an audio channel.
+     */
+    public synchronized void closeChannel(InputStream in) {
+
+        if(DEBUG) {
+            System.out.println("AudioDevice.closeChannel");
+        }
+
+        if (in == null) return;         // can't go anywhere here!
+
+        Info info;
+
+        for(int i=0; i<infos.size(); i++) {
+
+            info = (AudioDevice.Info)infos.elementAt(i);
+
+            if( info.in == in ) {
+
+                if( info.sequencer != null ) {
+
+                    info.sequencer.stop();
+                    //info.sequencer.close();
+                    infos.removeElement( info );
+
+                } else if( info.datapusher != null ) {
+
+                    info.datapusher.stop();
+                    infos.removeElement( info );
+                }
+            }
+        }
+        notify();
+    }
+
+
+    /**
+     * Open the device (done automatically)
+     */
+    public synchronized void open() {
+
+        // $$jb: 06.24.99: This is done on a per-stream
+        // basis using the new JS API now.
+    }
+
+
+    /**
+     * Close the device (done automatically)
+     */
+    public synchronized void close() {
+
+        // $$jb: 06.24.99: This is done on a per-stream
+        // basis using the new JS API now.
+
+    }
+
+
+    /**
+     * Play open audio stream(s)
+     */
+    public void play() {
+
+        // $$jb: 06.24.99:  Holdover from old architechture ...
+        // we now open/close the devices as needed on a per-stream
+        // basis using the JavaSound API.
+
+        if (DEBUG) {
+            System.out.println("exiting play()");
+        }
+    }
+
+    /**
+     * Close streams
+     */
+    public synchronized void closeStreams() {
+
+        Info info;
+
+        for(int i=0; i<infos.size(); i++) {
+
+            info = (AudioDevice.Info)infos.elementAt(i);
+
+            if( info.sequencer != null ) {
+
+                info.sequencer.stop();
+                info.sequencer.close();
+                infos.removeElement( info );
+
+            } else if( info.datapusher != null ) {
+
+                info.datapusher.stop();
+                infos.removeElement( info );
+            }
+        }
+
+
+        if (DEBUG) {
+            System.err.println("Audio Device: Streams all closed.");
+        }
+        // Empty the hash table.
+        clipStreams = new Hashtable();
+        infos = new Vector();
+    }
+
+    /**
+     * Number of channels currently open.
+     */
+    public int openChannels() {
+        return infos.size();
+    }
+
+    /**
+     * Make the debug info print out.
+     */
+    void setVerbose(boolean v) {
+        DEBUG = v;
+    }
+
+
+
+
+
+
+    // INFO CLASS
+
+    final class Info implements MetaEventListener {
+
+        final Sequencer   sequencer;
+        final InputStream in;
+        final DataPusher  datapusher;
+
+        Info( Sequencer sequencer, InputStream in, DataPusher datapusher ) {
+
+            this.sequencer  = sequencer;
+            this.in         = in;
+            this.datapusher = datapusher;
+        }
+
+        public void meta(MetaMessage event) {
+            if (event.getType() == 47 && sequencer != null) {
+                sequencer.close();
+            }
+        }
+    }
+
+
+
+}