/*

 * 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

     */

    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());

            }

        }

    }

}