Back to index...

	/*
	* 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 com.sun.media.sound;

	import java.io.DataInputStream;
	import java.io.DataOutputStream;
	import java.io.File;
	import java.io.FileInputStream;
	import java.io.IOException;
	import java.io.InputStream;
	import java.net.URL;

	import javax.sound.sampled.AudioFileFormat;
	import javax.sound.sampled.AudioFormat;
	import javax.sound.sampled.AudioInputStream;
	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 final class AiffFileReader extends SunFileReader {

	private static final int MAX_READ_LENGTH = 8;

	// 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.readUnsignedShort();
	if (channels <= 0) {
	throw new UnsupportedAudioFileException("Invalid number of channels");
	}
	dis.readInt(); // numSampleFrames
	int sampleSizeInBits = dis.readUnsignedShort();
	if (sampleSizeInBits < 1 \|\| sampleSizeInBits > 32) {
	throw new UnsupportedAudioFileException("Invalid AIFF/COMM sampleSize");
	}
	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;
	}
	}

Back to index...