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.EOFException;
	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;



	/**
	* WAVE file reader.
	*
	* @author Kara Kytle
	* @author Jan Borgersen
	* @author Florian Bomers
	*/
	public final class WaveFileReader extends SunFileReader {

	private static final int MAX_READ_LENGTH = 12;

	/**
	* 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 = getFMT(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 {
	InputStream urlStream = url.openStream(); // throws IOException
	AudioFileFormat fileFormat = null;
	try {
	fileFormat = getFMT(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 = getFMT(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 {
	// getFMT leaves the input stream at the beginning of the audio data
	AudioFileFormat fileFormat = getFMT(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 = getFMT(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 = getFMT(fis, false);
	} finally {
	if (fileFormat == null) {
	fis.close();
	}
	}
	return new AudioInputStream(fis, fileFormat.getFormat(), fileFormat.getFrameLength());
	}


	//--------------------------------------------------------------------


	private AudioFileFormat getFMT(InputStream stream, boolean doReset) throws UnsupportedAudioFileException, IOException {

	// assumes sream is rewound

	int bytesRead;
	int nread = 0;
	int fmt;
	int length = 0;
	int wav_type = 0;
	short channels;
	long sampleRate;
	long avgBytesPerSec;
	short blockAlign;
	int sampleSizeInBits;
	AudioFormat.Encoding encoding = null;

	DataInputStream dis = new DataInputStream( stream );

	if (doReset) {
	dis.mark(MAX_READ_LENGTH);
	}

	int magic = dis.readInt();
	int fileLength = rllong(dis);
	int waveMagic = dis.readInt();
	int totallength;
	if (fileLength <= 0) {
	fileLength = AudioSystem.NOT_SPECIFIED;
	totallength = AudioSystem.NOT_SPECIFIED;
	} else {
	totallength = fileLength + 8;
	}

	if ((magic != WaveFileFormat.RIFF_MAGIC) \|\| (waveMagic != WaveFileFormat.WAVE_MAGIC)) {
	// not WAVE, throw UnsupportedAudioFileException
	if (doReset) {
	dis.reset();
	}
	throw new UnsupportedAudioFileException("not a WAVE file");
	}

	// find and read the "fmt" chunk
	// we break out of this loop either by hitting EOF or finding "fmt "
	while(true) {

	try {
	fmt = dis.readInt();
	nread += 4;
	if( fmt==WaveFileFormat.FMT_MAGIC ) {
	// we've found the 'fmt' chunk
	break;
	} else {
	// else not 'fmt', skip this chunk
	length = rllong(dis);
	nread += 4;
	if (length % 2 > 0) length++;
	nread += dis.skipBytes(length);
	}
	} catch (EOFException eof) {
	// we've reached the end of the file without finding the 'fmt' chunk
	throw new UnsupportedAudioFileException("Not a valid WAV file");
	}
	}

	// Read the format chunk size.
	length = rllong(dis);
	nread += 4;

	// This is the nread position at the end of the format chunk
	int endLength = nread + length;

	// Read the wave format data out of the format chunk.

	// encoding.
	wav_type = rlshort(dis); nread += 2;

	if (wav_type == WaveFileFormat.WAVE_FORMAT_PCM)
	encoding = AudioFormat.Encoding.PCM_SIGNED; // if 8-bit, we need PCM_UNSIGNED, below...
	else if ( wav_type == WaveFileFormat.WAVE_FORMAT_ALAW )
	encoding = AudioFormat.Encoding.ALAW;
	else if ( wav_type == WaveFileFormat.WAVE_FORMAT_MULAW )
	encoding = AudioFormat.Encoding.ULAW;
	else {
	// we don't support any other WAVE formats....
	throw new UnsupportedAudioFileException("Not a supported WAV file");
	}
	// channels
	channels = rlshort(dis); nread += 2;
	if (channels <= 0) {
	throw new UnsupportedAudioFileException("Invalid number of channels");
	}

	// sample rate.
	sampleRate = rllong(dis); nread += 4;

	// this is the avgBytesPerSec
	avgBytesPerSec = rllong(dis); nread += 4;

	// this is blockAlign value
	blockAlign = rlshort(dis); nread += 2;

	// this is the PCM-specific value bitsPerSample
	sampleSizeInBits = (int)rlshort(dis); nread += 2;
	if (sampleSizeInBits <= 0) {
	throw new UnsupportedAudioFileException("Invalid bitsPerSample");
	}

	// if sampleSizeInBits==8, we need to use PCM_UNSIGNED
	if ((sampleSizeInBits==8) && encoding.equals(AudioFormat.Encoding.PCM_SIGNED))
	encoding = AudioFormat.Encoding.PCM_UNSIGNED;

	// skip any difference between the length of the format chunk
	// and what we read

	// if the length of the chunk is odd, there's an extra pad byte
	// at the end. i've never seen this in the fmt chunk, but we
	// should check to make sure.

	if (length % 2 != 0) length += 1;

	// $$jb: 07.28.99: endLength>nread, not length>nread.
	// This fixes #4257986
	if (endLength > nread)
	nread += dis.skipBytes(endLength - nread);

	// we have a format now, so find the "data" chunk
	// we break out of this loop either by hitting EOF or finding "data"
	// $$kk: if "data" chunk precedes "fmt" chunk we are hosed -- can this legally happen?
	nread = 0;
	while(true) {
	try{
	int datahdr = dis.readInt();
	nread+=4;
	if (datahdr == WaveFileFormat.DATA_MAGIC) {
	// we've found the 'data' chunk
	break;
	} else {
	// else not 'data', skip this chunk
	int thisLength = rllong(dis); nread += 4;
	if (thisLength % 2 > 0) thisLength++;
	nread += dis.skipBytes(thisLength);
	}
	} catch (EOFException eof) {
	// we've reached the end of the file without finding the 'data' chunk
	throw new UnsupportedAudioFileException("Not a valid WAV file");
	}
	}
	// this is the length of the data chunk
	int dataLength = rllong(dis); nread += 4;

	// now build the new AudioFileFormat and return

	AudioFormat format = new AudioFormat(encoding,
	(float)sampleRate,
	sampleSizeInBits, channels,
	calculatePCMFrameSize(sampleSizeInBits, channels),
	(float)sampleRate, false);

	return new WaveFileFormat(AudioFileFormat.Type.WAVE,
	totallength,
	format,
	dataLength / format.getFrameSize());
	}
	}

Back to index...