/* * Copyright (c) 1999, 2007, 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 com.sun.media.sound; import java.util.Vector;import java.io.File;import java.io.InputStream;import java.io.OutputStream;import java.io.IOException;import java.io.EOFException;import java.net.URL;import java.net.MalformedURLException; import java.io.BufferedInputStream;import java.io.BufferedOutputStream;import java.io.DataInputStream;import java.io.FileInputStream;import java.io.DataOutputStream;import java.io.FileOutputStream;import java.io.ByteArrayInputStream;import java.io.ByteArrayOutputStream;import java.io.SequenceInputStream; import javax.sound.sampled.AudioFileFormat;import javax.sound.sampled.AudioInputStream;import javax.sound.sampled.AudioFormat;import javax.sound.sampled.AudioSystem;import javax.sound.sampled.UnsupportedAudioFileException;  /** * AIFF file reader and writer. * * @author Kara Kytle * @author Jan Borgersen * @author Florian Bomers */public class AiffFileReader extends SunFileReader  {     private static final int MAX_READ_LENGTH = 8;      /**     * AIFF parser type     */    public static final AudioFileFormat.Type types[] = {        AudioFileFormat.Type.AIFF    };      /**     * Constructs a new AiffParser object.     */    public AiffFileReader() {    }        // METHODS TO IMPLEMENT AudioFileReader     /**     * Obtains the audio file format of the input stream provided.  The stream must     * point to valid audio file data.  In general, audio file providers may     * need to read some data from the stream before determining whether they     * support it.  These parsers must     * be able to mark the stream, read enough data to determine whether they     * support the stream, and, if not, reset the stream's read pointer to its original     * position.  If the input stream does not support this, this method may fail     * with an IOException.     * @param stream the input stream from which file format information should be     * extracted     * @return an <code>AudioFileFormat</code> object describing the audio file format     * @throws UnsupportedAudioFileException if the stream does not point to valid audio     * file data recognized by the system     * @throws IOException if an I/O exception occurs     * @see InputStream#markSupported     * @see InputStream#mark     */    public AudioFileFormat getAudioFileFormat(InputStream stream) throws UnsupportedAudioFileException, IOException {        // fix for 4489272: AudioSystem.getAudioFileFormat() fails for InputStream, but works for URL        AudioFileFormat aff = getCOMM(stream, true);        // the following is not strictly necessary - but was implemented like that in 1.3.0 - 1.4.1        // so I leave it as it was. May remove this for 1.5.0        stream.reset();        return aff;    }      /**     * Obtains the audio file format of the URL provided.  The URL must     * point to valid audio file data.     * @param url the URL from which file format information should be     * extracted     * @return an <code>AudioFileFormat</code> object describing the audio file format     * @throws UnsupportedAudioFileException if the URL does not point to valid audio     * file data recognized by the system     * @throws IOException if an I/O exception occurs     */    public AudioFileFormat getAudioFileFormat(URL url) throws UnsupportedAudioFileException, IOException {        AudioFileFormat fileFormat = null;        InputStream urlStream = url.openStream();       // throws IOException        try {            fileFormat = getCOMM(urlStream, false);        } finally {            urlStream.close();        }        return fileFormat;    }      /**     * Obtains the audio file format of the File provided.  The File must     * point to valid audio file data.     * @param file the File from which file format information should be     * extracted     * @return an <code>AudioFileFormat</code> object describing the audio file format     * @throws UnsupportedAudioFileException if the File does not point to valid audio     * file data recognized by the system     * @throws IOException if an I/O exception occurs     */    public AudioFileFormat getAudioFileFormat(File file) throws UnsupportedAudioFileException, IOException {        AudioFileFormat fileFormat = null;        FileInputStream fis = new FileInputStream(file);       // throws IOException        // part of fix for 4325421        try {            fileFormat = getCOMM(fis, false);        } finally {            fis.close();        }         return fileFormat;    }        /**     * Obtains an audio stream from the input stream provided.  The stream must     * point to valid audio file data.  In general, audio file providers may     * need to read some data from the stream before determining whether they     * support it.  These parsers must     * be able to mark the stream, read enough data to determine whether they     * support the stream, and, if not, reset the stream's read pointer to its original     * position.  If the input stream does not support this, this method may fail     * with an IOException.     * @param stream the input stream from which the <code>AudioInputStream</code> should be     * constructed     * @return an <code>AudioInputStream</code> object based on the audio file data contained     * in the input stream.     * @throws UnsupportedAudioFileException if the stream does not point to valid audio     * file data recognized by the system     * @throws IOException if an I/O exception occurs     * @see InputStream#markSupported     * @see InputStream#mark     */    public AudioInputStream getAudioInputStream(InputStream stream) throws UnsupportedAudioFileException, IOException {        // getCOMM leaves the input stream at the beginning of the audio data        AudioFileFormat fileFormat = getCOMM(stream, true);     // throws UnsupportedAudioFileException, IOException         // we've got everything, and the stream is at the        // beginning of the audio data, so return an AudioInputStream.        return new AudioInputStream(stream, fileFormat.getFormat(), fileFormat.getFrameLength());    }      /**     * Obtains an audio stream from the URL provided.  The URL must     * point to valid audio file data.     * @param url the URL for which the <code>AudioInputStream</code> should be     * constructed     * @return an <code>AudioInputStream</code> object based on the audio file data pointed     * to by the URL     * @throws UnsupportedAudioFileException if the URL does not point to valid audio     * file data recognized by the system     * @throws IOException if an I/O exception occurs     */    public AudioInputStream getAudioInputStream(URL url) throws UnsupportedAudioFileException, IOException {        InputStream urlStream = url.openStream();  // throws IOException        AudioFileFormat fileFormat = null;        try {            fileFormat = getCOMM(urlStream, false);        } finally {            if (fileFormat == null) {                urlStream.close();            }        }        return new AudioInputStream(urlStream, fileFormat.getFormat(), fileFormat.getFrameLength());    }      /**     * Obtains an audio stream from the File provided.  The File must     * point to valid audio file data.     * @param file the File for which the <code>AudioInputStream</code> should be     * constructed     * @return an <code>AudioInputStream</code> object based on the audio file data pointed     * to by the File     * @throws UnsupportedAudioFileException if the File does not point to valid audio     * file data recognized by the system     * @throws IOException if an I/O exception occurs     */    public AudioInputStream getAudioInputStream(File file)        throws UnsupportedAudioFileException, IOException {         FileInputStream fis = new FileInputStream(file); // throws IOException        AudioFileFormat fileFormat = null;        // part of fix for 4325421        try {            fileFormat = getCOMM(fis, false);        } finally {            if (fileFormat == null) {                fis.close();            }        }        return new AudioInputStream(fis, fileFormat.getFormat(), fileFormat.getFrameLength());    }     //--------------------------------------------------------------------     private AudioFileFormat getCOMM(InputStream is, boolean doReset)        throws UnsupportedAudioFileException, IOException {         DataInputStream dis = new DataInputStream(is);         if (doReset) {            dis.mark(MAX_READ_LENGTH);        }         // assumes a stream at the beginning of the file which has already        // passed the magic number test...        // leaves the input stream at the beginning of the audio data        int fileRead = 0;        int dataLength = 0;        AudioFormat format = null;         // Read the magic number        int magic = dis.readInt();         // $$fb: fix for 4369044: javax.sound.sampled.AudioSystem.getAudioInputStream() works wrong with Cp037        if (magic != AiffFileFormat.AIFF_MAGIC) {            // not AIFF, throw exception            if (doReset) {                dis.reset();            }            throw new UnsupportedAudioFileException("not an AIFF file");        }         int length = dis.readInt();        int iffType = dis.readInt();        fileRead += 12;         int totallength;        if(length <= 0 ) {            length = AudioSystem.NOT_SPECIFIED;            totallength = AudioSystem.NOT_SPECIFIED;        } else {            totallength = length + 8;        }         // Is this an AIFC or just plain AIFF file.        boolean aifc = false;        // $$fb: fix for 4369044: javax.sound.sampled.AudioSystem.getAudioInputStream() works wrong with Cp037        if (iffType ==  AiffFileFormat.AIFC_MAGIC) {            aifc = true;        }         // Loop through the AIFF chunks until        // we get to the SSND chunk.        boolean ssndFound = false;        while (!ssndFound) {            // Read the chunk name            int chunkName = dis.readInt();            int chunkLen = dis.readInt();            fileRead += 8;             int chunkRead = 0;             // Switch on the chunk name.            switch (chunkName) {            case AiffFileFormat.FVER_MAGIC:                // Ignore format version for now.                break;             case AiffFileFormat.COMM_MAGIC:                // AIFF vs. AIFC                // $$fb: fix for 4399551: Repost of bug candidate: cannot replay aif file (Review ID: 108108)                if ((!aifc && chunkLen < 18) || (aifc && chunkLen < 22)) {                    throw new UnsupportedAudioFileException("Invalid AIFF/COMM chunksize");                }                // Read header info.                int channels = dis.readShort();                dis.readInt();                int sampleSizeInBits = dis.readShort();                float sampleRate = (float) read_ieee_extended(dis);                chunkRead += (2 + 4 + 2 + 10);                 // If this is not AIFC then we assume it's                // a linearly encoded file.                AudioFormat.Encoding encoding = AudioFormat.Encoding.PCM_SIGNED;                 if (aifc) {                    int enc = dis.readInt(); chunkRead += 4;                    switch (enc) {                    case AiffFileFormat.AIFC_PCM:                        encoding = AudioFormat.Encoding.PCM_SIGNED;                        break;                    case AiffFileFormat.AIFC_ULAW:                        encoding = AudioFormat.Encoding.ULAW;                        sampleSizeInBits = 8; // Java Sound convention                        break;                    default:                        throw new UnsupportedAudioFileException("Invalid AIFF encoding");                    }                }                int frameSize = calculatePCMFrameSize(sampleSizeInBits, channels);                //$fb what's that ??                //if (sampleSizeInBits == 8) {                //    encoding = AudioFormat.Encoding.PCM_SIGNED;                //}                format =  new AudioFormat(encoding, sampleRate,                                          sampleSizeInBits, channels,                                          frameSize, sampleRate, true);                break;            case AiffFileFormat.SSND_MAGIC:                // Data chunk.                // we are getting *weird* numbers for chunkLen sometimes;                // this really should be the size of the data chunk....                int dataOffset = dis.readInt();                int blocksize = dis.readInt();                chunkRead += 8;                 // okay, now we are done reading the header.  we need to set the size                // of the data segment.  we know that sometimes the value we get for                // the chunksize is absurd.  this is the best i can think of:if the                // value seems okay, use it.  otherwise, we get our value of                // length by assuming that everything left is the data segment;                // its length should be our original length (for all AIFF data chunks)                // minus what we've read so far.                // $$kk: we should be able to get length for the data chunk right after                // we find "SSND."  however, some aiff files give *weird* numbers.  what                // is going on??                 if (chunkLen < length) {                    dataLength = chunkLen - chunkRead;                } else {                    // $$kk: 11.03.98: this seems dangerous!                    dataLength = length - (fileRead + chunkRead);                }                ssndFound = true;                break;            } // switch            fileRead += chunkRead;            // skip the remainder of this chunk            if (!ssndFound) {                int toSkip = chunkLen - chunkRead;                if (toSkip > 0) {                    fileRead += dis.skipBytes(toSkip);                }            }        } // while         if (format == null) {            throw new UnsupportedAudioFileException("missing COMM chunk");        }        AudioFileFormat.Type type = aifc?AudioFileFormat.Type.AIFC:AudioFileFormat.Type.AIFF;         return new AiffFileFormat(type, totallength, format, dataLength / format.getFrameSize());    }     // HELPER METHODS    /** write_ieee_extended(DataOutputStream dos, double f) throws IOException {     * Extended precision IEEE floating-point conversion routine.     * @argument DataOutputStream     * @argument double     * @return void     * @exception IOException     */    private void write_ieee_extended(DataOutputStream dos, double f) throws IOException {         int exponent = 16398;        double highMantissa = f;         // For now write the integer portion of f        // $$jb: 03.30.99: stay in synch with JMF on this!!!!        while (highMantissa < 44000) {            highMantissa *= 2;            exponent--;        }        dos.writeShort(exponent);        dos.writeInt( ((int) highMantissa) << 16);        dos.writeInt(0); // low Mantissa    }      /**     * read_ieee_extended     * Extended precision IEEE floating-point conversion routine.     * @argument DataInputStream     * @return double     * @exception IOException     */    private double read_ieee_extended(DataInputStream dis) throws IOException {         double f = 0;        int expon = 0;        long hiMant = 0, loMant = 0;        long t1, t2;        double HUGE = ((double)3.40282346638528860e+38);          expon = dis.readUnsignedShort();         t1 = (long)dis.readUnsignedShort();        t2 = (long)dis.readUnsignedShort();        hiMant = t1 << 16 | t2;         t1 = (long)dis.readUnsignedShort();        t2 = (long)dis.readUnsignedShort();        loMant = t1 << 16 | t2;         if (expon == 0 && hiMant == 0 && loMant == 0) {            f = 0;        } else {            if (expon == 0x7FFF)                f = HUGE;            else {                expon -= 16383;                expon -= 31;                f = (hiMant * Math.pow(2, expon));                expon -= 32;                f += (loMant * Math.pow(2, expon));            }        }         return f;    }   }