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

jdkSrc/jdk8/javax/sound/sampled/AudioInputStream.java

@@ -0,0 +1,515 @@
+/*
+ * Copyright (c) 1999, 2005, 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 javax.sound.sampled;
+
+import java.io.InputStream;
+import java.io.PushbackInputStream;
+import java.io.IOException;
+
+
+/**
+ * An audio input stream is an input stream with a specified audio format and
+ * length.  The length is expressed in sample frames, not bytes.
+ * Several methods are provided for reading a certain number of bytes from
+ * the stream, or an unspecified number of bytes.
+ * The audio input stream keeps track  of the last byte that was read.
+ * You can skip over an arbitrary number of bytes to get to a later position
+ * for reading. An audio input stream may support marks.  When you set a mark,
+ * the current position is remembered so that you can return to it later.
+ * <p>
+ * The <code>AudioSystem</code> class includes many methods that manipulate
+ * <code>AudioInputStream</code> objects.
+ * For example, the methods let you:
+ * <ul>
+ * <li> obtain an
+ * audio input stream from an external audio file, stream, or URL
+ * <li> write an external file from an audio input stream
+ * <li> convert an audio input stream to a different audio format
+ * </ul>
+ *
+ * @author David Rivas
+ * @author Kara Kytle
+ * @author Florian Bomers
+ *
+ * @see AudioSystem
+ * @see Clip#open(AudioInputStream) Clip.open(AudioInputStream)
+ * @since 1.3
+ */
+public class AudioInputStream extends InputStream {
+
+    /**
+     * The <code>InputStream</code> from which this <code>AudioInputStream</code>
+     * object was constructed.
+     */
+    private InputStream stream;
+
+    /**
+     * The format of the audio data contained in the stream.
+     */
+    protected AudioFormat format;
+
+    /**
+     * This stream's length, in sample frames.
+     */
+    protected long frameLength;
+
+    /**
+     * The size of each frame, in bytes.
+     */
+    protected int frameSize;
+
+    /**
+     * The current position in this stream, in sample frames (zero-based).
+     */
+    protected long framePos;
+
+    /**
+     * The position where a mark was set.
+     */
+    private long markpos;
+
+    /**
+     * When the underlying stream could only return
+     * a non-integral number of frames, store
+     * the remainder in a temporary buffer
+     */
+    private byte[] pushBackBuffer = null;
+
+    /**
+     * number of valid bytes in the pushBackBuffer
+     */
+    private int pushBackLen = 0;
+
+    /**
+     * MarkBuffer at mark position
+     */
+    private byte[] markPushBackBuffer = null;
+
+    /**
+     * number of valid bytes in the markPushBackBuffer
+     */
+    private int markPushBackLen = 0;
+
+
+    /**
+     * Constructs an audio input stream that has the requested format and length in sample frames,
+     * using audio data from the specified input stream.
+     * @param stream the stream on which this <code>AudioInputStream</code>
+     * object is based
+     * @param format the format of this stream's audio data
+     * @param length the length in sample frames of the data in this stream
+     */
+    public AudioInputStream(InputStream stream, AudioFormat format, long length) {
+
+        super();
+
+        this.format = format;
+        this.frameLength = length;
+        this.frameSize = format.getFrameSize();
+
+        // any frameSize that is not well-defined will
+        // cause that this stream will be read in bytes
+        if( this.frameSize == AudioSystem.NOT_SPECIFIED || frameSize <= 0) {
+            this.frameSize = 1;
+        }
+
+        this.stream = stream;
+        framePos = 0;
+        markpos = 0;
+    }
+
+
+    /**
+     * Constructs an audio input stream that reads its data from the target
+     * data line indicated.  The format of the stream is the same as that of
+     * the target data line, and the length is AudioSystem#NOT_SPECIFIED.
+     * @param line the target data line from which this stream obtains its data.
+     * @see AudioSystem#NOT_SPECIFIED
+     */
+    public AudioInputStream(TargetDataLine line) {
+
+        TargetDataLineInputStream tstream = new TargetDataLineInputStream(line);
+        format = line.getFormat();
+        frameLength = AudioSystem.NOT_SPECIFIED;
+        frameSize = format.getFrameSize();
+
+        if( frameSize == AudioSystem.NOT_SPECIFIED || frameSize <= 0) {
+            frameSize = 1;
+        }
+        this.stream = tstream;
+        framePos = 0;
+        markpos = 0;
+    }
+
+
+    /**
+     * Obtains the audio format of the sound data in this audio input stream.
+     * @return an audio format object describing this stream's format
+     */
+    public AudioFormat getFormat() {
+        return format;
+    }
+
+
+    /**
+     * Obtains the length of the stream, expressed in sample frames rather than bytes.
+     * @return the length in sample frames
+     */
+    public long getFrameLength() {
+        return frameLength;
+    }
+
+
+    /**
+     * Reads the next byte of data from the audio input stream.  The audio input
+     * stream's frame size must be one byte, or an <code>IOException</code>
+     * will be thrown.
+     *
+     * @return the next byte of data, or -1 if the end of the stream is reached
+     * @throws IOException if an input or output error occurs
+     * @see #read(byte[], int, int)
+     * @see #read(byte[])
+     * @see #available
+     * <p>
+     */
+    public int read() throws IOException {
+        if( frameSize != 1 ) {
+            throw new IOException("cannot read a single byte if frame size > 1");
+        }
+
+        byte[] data = new byte[1];
+        int temp = read(data);
+        if (temp <= 0) {
+            // we have a weird situation if read(byte[]) returns 0!
+            return -1;
+        }
+        return data[0] & 0xFF;
+    }
+
+
+    /**
+     * Reads some number of bytes from the audio input stream and stores them into
+     * the buffer array <code>b</code>. The number of bytes actually read is
+     * returned as an integer. This method blocks until input data is
+     * available, the end of the stream is detected, or an exception is thrown.
+     * <p>This method will always read an integral number of frames.
+     * If the length of the array is not an integral number
+     * of frames, a maximum of <code>b.length - (b.length % frameSize)
+     * </code> bytes will be read.
+     *
+     * @param b the buffer into which the data is read
+     * @return the total number of bytes read into the buffer, or -1 if there
+     * is no more data because the end of the stream has been reached
+     * @throws IOException if an input or output error occurs
+     * @see #read(byte[], int, int)
+     * @see #read()
+     * @see #available
+     */
+    public int read(byte[] b) throws IOException {
+        return read(b,0,b.length);
+    }
+
+
+    /**
+     * Reads up to a specified maximum number of bytes of data from the audio
+     * stream, putting them into the given byte array.
+     * <p>This method will always read an integral number of frames.
+     * If <code>len</code> does not specify an integral number
+     * of frames, a maximum of <code>len - (len % frameSize)
+     * </code> bytes will be read.
+     *
+     * @param b the buffer into which the data is read
+     * @param off the offset, from the beginning of array <code>b</code>, at which
+     * the data will be written
+     * @param len the maximum number of bytes to read
+     * @return the total number of bytes read into the buffer, or -1 if there
+     * is no more data because the end of the stream has been reached
+     * @throws IOException if an input or output error occurs
+     * @see #read(byte[])
+     * @see #read()
+     * @see #skip
+     * @see #available
+     */
+    public int read(byte[] b, int off, int len) throws IOException {
+
+        // make sure we don't read fractions of a frame.
+        if( (len%frameSize) != 0 ) {
+            len -= (len%frameSize);
+            if (len == 0) {
+                return 0;
+            }
+        }
+
+        if( frameLength != AudioSystem.NOT_SPECIFIED ) {
+            if( framePos >= frameLength ) {
+                return -1;
+            } else {
+
+                // don't try to read beyond our own set length in frames
+                if( (len/frameSize) > (frameLength-framePos) ) {
+                    len = (int) (frameLength-framePos) * frameSize;
+                }
+            }
+        }
+
+        int bytesRead = 0;
+        int thisOff = off;
+
+        // if we've bytes left from last call to read(),
+        // use them first
+        if (pushBackLen > 0 && len >= pushBackLen) {
+            System.arraycopy(pushBackBuffer, 0,
+                             b, off, pushBackLen);
+            thisOff += pushBackLen;
+            len -= pushBackLen;
+            bytesRead += pushBackLen;
+            pushBackLen = 0;
+        }
+
+        int thisBytesRead = stream.read(b, thisOff, len);
+        if (thisBytesRead == -1) {
+            return -1;
+        }
+        if (thisBytesRead > 0) {
+            bytesRead += thisBytesRead;
+        }
+        if (bytesRead > 0) {
+            pushBackLen = bytesRead % frameSize;
+            if (pushBackLen > 0) {
+                // copy everything we got from the beginning of the frame
+                // to our pushback buffer
+                if (pushBackBuffer == null) {
+                    pushBackBuffer = new byte[frameSize];
+                }
+                System.arraycopy(b, off + bytesRead - pushBackLen,
+                                 pushBackBuffer, 0, pushBackLen);
+                bytesRead -= pushBackLen;
+            }
+            // make sure to update our framePos
+            framePos += bytesRead/frameSize;
+        }
+        return bytesRead;
+    }
+
+
+    /**
+     * Skips over and discards a specified number of bytes from this
+     * audio input stream.
+     * @param n the requested number of bytes to be skipped
+     * @return the actual number of bytes skipped
+     * @throws IOException if an input or output error occurs
+     * @see #read
+     * @see #available
+     */
+    public long skip(long n) throws IOException {
+
+        // make sure not to skip fractional frames
+        if( (n%frameSize) != 0 ) {
+            n -= (n%frameSize);
+        }
+
+        if( frameLength != AudioSystem.NOT_SPECIFIED ) {
+            // don't skip more than our set length in frames.
+            if( (n/frameSize) > (frameLength-framePos) ) {
+                n = (frameLength-framePos) * frameSize;
+            }
+        }
+        long temp = stream.skip(n);
+
+        // if no error, update our position.
+        if( temp%frameSize != 0 ) {
+
+            // Throw an IOException if we've skipped a fractional number of frames
+            throw new IOException("Could not skip an integer number of frames.");
+        }
+        if( temp >= 0 ) {
+            framePos += temp/frameSize;
+        }
+        return temp;
+
+    }
+
+
+    /**
+     * Returns the maximum number of bytes that can be read (or skipped over) from this
+     * audio input stream without blocking.  This limit applies only to the next invocation of
+     * a <code>read</code> or <code>skip</code> method for this audio input stream; the limit
+     * can vary each time these methods are invoked.
+     * Depending on the underlying stream,an IOException may be thrown if this
+     * stream is closed.
+     * @return the number of bytes that can be read from this audio input stream without blocking
+     * @throws IOException if an input or output error occurs
+     * @see #read(byte[], int, int)
+     * @see #read(byte[])
+     * @see #read()
+     * @see #skip
+     */
+    public int available() throws IOException {
+
+        int temp = stream.available();
+
+        // don't return greater than our set length in frames
+        if( (frameLength != AudioSystem.NOT_SPECIFIED) && ( (temp/frameSize) > (frameLength-framePos)) ) {
+            return (int) (frameLength-framePos) * frameSize;
+        } else {
+            return temp;
+        }
+    }
+
+
+    /**
+     * Closes this audio input stream and releases any system resources associated
+     * with the stream.
+     * @throws IOException if an input or output error occurs
+     */
+    public void close() throws IOException {
+        stream.close();
+    }
+
+
+    /**
+     * Marks the current position in this audio input stream.
+     * @param readlimit the maximum number of bytes that can be read before
+     * the mark position becomes invalid.
+     * @see #reset
+     * @see #markSupported
+     */
+
+    public void mark(int readlimit) {
+
+        stream.mark(readlimit);
+        if (markSupported()) {
+            markpos = framePos;
+            // remember the pushback buffer
+            markPushBackLen = pushBackLen;
+            if (markPushBackLen > 0) {
+                if (markPushBackBuffer == null) {
+                    markPushBackBuffer = new byte[frameSize];
+                }
+                System.arraycopy(pushBackBuffer, 0, markPushBackBuffer, 0, markPushBackLen);
+            }
+        }
+    }
+
+
+    /**
+     * Repositions this audio input stream to the position it had at the time its
+     * <code>mark</code> method was last invoked.
+     * @throws IOException if an input or output error occurs.
+     * @see #mark
+     * @see #markSupported
+     */
+    public void reset() throws IOException {
+
+        stream.reset();
+        framePos = markpos;
+        // re-create the pushback buffer
+        pushBackLen = markPushBackLen;
+        if (pushBackLen > 0) {
+            if (pushBackBuffer == null) {
+                pushBackBuffer = new byte[frameSize - 1];
+            }
+            System.arraycopy(markPushBackBuffer, 0, pushBackBuffer, 0, pushBackLen);
+        }
+    }
+
+
+    /**
+     * Tests whether this audio input stream supports the <code>mark</code> and
+     * <code>reset</code> methods.
+     * @return <code>true</code> if this stream supports the <code>mark</code>
+     * and <code>reset</code> methods; <code>false</code> otherwise
+     * @see #mark
+     * @see #reset
+     */
+    public boolean markSupported() {
+
+        return stream.markSupported();
+    }
+
+
+    /**
+     * Private inner class that makes a TargetDataLine look like an InputStream.
+     */
+    private class TargetDataLineInputStream extends InputStream {
+
+        /**
+         * The TargetDataLine on which this TargetDataLineInputStream is based.
+         */
+        TargetDataLine line;
+
+
+        TargetDataLineInputStream(TargetDataLine line) {
+            super();
+            this.line = line;
+        }
+
+
+        public int available() throws IOException {
+            return line.available();
+        }
+
+        //$$fb 2001-07-16: added this method to correctly close the underlying TargetDataLine.
+        // fixes bug 4479984
+        public void close() throws IOException {
+            // the line needs to be flushed and stopped to avoid a dead lock...
+            // Probably related to bugs 4417527, 4334868, 4383457
+            if (line.isActive()) {
+                line.flush();
+                line.stop();
+            }
+            line.close();
+        }
+
+        public int read() throws IOException {
+
+            byte[] b = new byte[1];
+
+            int value = read(b, 0, 1);
+
+            if (value == -1) {
+                return -1;
+            }
+
+            value = (int)b[0];
+
+            if (line.getFormat().getEncoding().equals(AudioFormat.Encoding.PCM_SIGNED)) {
+                value += 128;
+            }
+
+            return value;
+        }
+
+
+        public int read(byte[] b, int off, int len) throws IOException {
+            try {
+                return line.read(b, off, len);
+            } catch (IllegalArgumentException e) {
+                throw new IOException(e.getMessage());
+            }
+        }
+    }
+}