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;

public final class AiffFileReader extends SunFileReader {

private static final int MAX_READ_LENGTH = 8;

/**

public AiffFileReader() {

}

// METHODS TO IMPLEMENT AudioFileReader

/**

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;

}

/**

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;

}

/**

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;

}

/**

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

}

/**

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

}

/**

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 {

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

}

/**

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;

}

}